Storage Classes CS 110B - Rule Storage Classes Page 18-1 \handouts\storclas

Transcription

1 CS 110B - Rule Storage Classes Page 18-1 Attributes are distinctive features of a variable. Data type, int or double for example, is an attribute. Storage class is another attribute. There are four storage classes: extern(external), auto(automatic), static, and register. Storage class is indicated by the declaration of the variable as well as the location of the declaration. Storage class determines scope, duration, and linkage. Scope The scope of an identifier is that part of the program where the identifier can be used. We will consider four of five scopes: Function Prototype Scope starts at the beginning of the argument list and ends at the end of the prototype, that is, within the parentheses enclosing the argument list. double funa(int a, double b, float c); Dummy names, a, b, and c, have function prototype scope. This basically means that the compiler only pays attention to the data types, not the dummy identifiers. Block or Local Scope starts at the declaration of the variable and ends at the end of the block containing the declaration. Local variables and formal arguments have block scope. 1 void funb(int num) 2 { 3 int count; } // num and count go out of scope Identifiers, num and count, have block scope. File or Global Scope pertains to external (global) variables that are declared outside of all functions. File scope starts at the declaration and ends at the end of the source file. Thus, an external variable can be accessed by all functions in the file following the variable declaration. Class Scope pertains to members declared in a class. Within the class's scope which is the class declaration and member functions, data members and member functions can be directly accessed by name. Outside the class's scope, class members only can be referenced through an object, a reference to an object, or a pointer to an object. This means you can use same identifier in different classes without a conflict.

2 CS 110B - Rule Storage Classes Page 18-2 Visibility Visibility is the part of the program where the variable can be used to access the stored data. Visibility and scope are usually the same. There are situations where the data still exists in memory, but is hidden by the usage of a duplicate variable. 11 { // Begin Outer Block 12 int a, b; // local to outer block 13 a = 2; // a and b are in scope and visible { // Begin Inner Block: body of loop or true path or false path of if 16 float a; // local to inner block 17 a = 22.5F; // float a is in scope and visible 18 // int a is in scope but hidden (not visible) 19 b = 3; // int b is in scope and visible } // End Inner Block 22 // float a is out of scope 23 a++; // int a is visible and now equal to 3 24 } // End Outer Block // int a and b are out of scope float a 22.5 Inner Block int b 3 Outer Block int a 2 Generally, inner blocks (or sub-blocks) are not used except for loops and if blocks. Defining a variable within a sub-block puts its defining declaration close to the usage, and the variable is in existence on the stack only within the sub-block. In other words, when control exits the sub-block, its local variables are popped off the stack.

3 CS 110B - Rule Storage Classes Page 18-3 Storage Duration (Lifetime) Duration defines the time period during which memory is actually allocated to a variable. There are three kinds of duration. Local or automatic duration is the duration of local or automatic variables and formal arguments. They are pushed onto the stack (allocated) when their block in entered and popped from the stack (deallocated) when their block is exited. Local variables must be explicitly initialized; otherwise, they contain garbage. The exception is elements of a partially initialized local array that are not explicitly initialized are automatically set to zero. Static duration is the duration of variables that are allocated permanent memory as soon as execution of main() begins and remain allocated until the program terminates. Unlike automatic duration, the number of variables having static duration remains fixed during program execution. Thus, a stack is not needed to manage them, but a fixed block of memory is allocated for the static variables. All variables with file scope (external variables) have static duration. Both local and external variables can be declared to have static duration. All variables having static duration are initialized to zero. All functions have static duration, meaning they are stored in memory as long as the program is executing. Dynamic duration is the duration of data objects that are allocated and deallocated dynamically by the operators, new and delete, respectively. The dynamic memory space is known as the free store. Storage classes do not apply to these data objects, but do apply to the pointer variables that point to these objects. Linkage The linker combines the object code from the C++ program, the start-up code for the particular system, and the library code into an executable file. Linkage is the process that allows each variable to be associated with one particular part of storage (data object). There are three linkage attributes. External linkage means that a name can be used anywhere in a multifile program. Internal linkage means that a name can be used anywhere in a single file program. No linkage means that a name can be used only in the block where it is defined. Variables with internal and external linkage can appear in multiple declarations. Variables with no linkage can appear in only one declaration.

4 CS 110B - Rule Storage Classes Page 18-4 External Variables External variables have file or global scope, static duration, and external linkage. 31 int x; // Defining declaration for external variable; memory is allocated 32 // x is automatically initialized to zero 33 void funx1(); // Prototypes 34 void funx2(); int main() 37 { 38 extern int x; // Referencing declaration; no memory is allocated 39 x++; // global x becomes 1 40 funx1(); 41 funx2(); } void funx1() 46 { 47 extern int x; // Referencing declaration; refers to existing global 48 x++; // variable x which becomes 2 here } void funx2() 53 { 54 int x = 23; // Defining declaration for local variable 55 x++; // Local x becomes ::x++; // Increment global x to } Recalling that external variables have file scope, the referencing declarations in main() and funx1() are equivalent to having no declarations. Thus, a referencing declaration is for documentation only. It tells the compiler that any reference in main() or funx1() to the variable x refers to a variable that is defined externally to the block, in the same program file or even another file. Generally, these referencing declarations are rarely used except in multifile programs. Omitting the keyword extern in funx2() causes the compiler to create a local variable known only to funx2(), visible only when funx2() is executing. When control returns to main(), a reference to x would refer to the external variable. A variable in block scope hides a variable of the same name in file scope when the block is being executed. In line 56, the unary scope resolution operator prefixing x means the global x. Keyword extern is only used to reference an existing external variable. An external variable can be initialized only when it is defined, not when it is referenced. extern int x = 10; // Invalid initialization With a multiple file program, only one file can contain the definition of an external variable. Other files that need to access that variable must use the keyword extern in a referencing declaration.

5 CS 110B - Rule Storage Classes Page 18-5 Automatic or Local Variables Automatic or local variables have block or local scope, automatic or local duration, and no linkage. Storage class auto is the default for local variables. Formal arguments are also class auto. 61 { 62 int a; // is equivalent to auto int a; } Keyword auto is generally not used since it can only be used when variables are automatic by default. In funx2(), auto could have been used in line 54 to indicate that an automatic variable is being created to override the global variable. Static Variables Local static variables have block or local scope, static duration, and no linkage. 71 void funs(); int main() 74 { 75 for (int i = 1; i <= 3; i++) 76 funs(); 77 return 0; 78 } void funs() 81 { 82 int loc = 1; // Local variable is initialized at each call to funs() static int stat = 1; // Static variable is initialized once 85 // when program execution begins 86 cout << "local: " << loc << " static: " << stat << '\n'; 87 loc++; 88 stat++; 89 } Output: local: 1 static: 1 local: 1 static: 2 local: 1 static: 3 A local static variable is accessible only in its block, but maintains its value for the entire program. Good usage would be: if a function needs to initialize a variable only once in the program or needs a variable to maintain its value for the entire program.

6 CS 110B - Rule Storage Classes Page 18-6 External static variables can be used only by functions in the same program file. An ordinary external variable can be used in multiple files. Thus, the difference between an external static variable and an ordinary external variable is the linkage. External static variables have file or global scope, static duration, and internal linkage. External declared constants are treated as if they are static, that is, they have internal linkage. The reason for this is that it is typical to put declared constants in a header file. If you included this header file in multiple files, all of these files would contain the definitions of the constants. This would be an error if the constants had external linkage. Recall that only one file can contain the definition of an external variable and the other files must have a referencing declaration which cannot have an initializer. Each file has its own set of constants rather than sharing them with other files. Putting the constants in a header file and including the header file ensures that the constants are the same in all files. Register Variables Register variables have block scope, local duration, and no linkage. Automatic variables are stored on the stack which is part of the computer s main memory. A declaration for an automatic variable or a formal argument can be preceded by the keyword register. The data type must be int or char. 91 void funr(register int n) 92 { 93 register int index; // or register index; } This is a request, not a command, to the compiler to allocate a register in the Arithmetic/Logic Unit to the variable rather than a location in main memory. If possible, the value will be stored in a register which has faster access than main memory. Otherwise, the variable will be allocated on the stack as an ordinary local variable. You get no message that the request for a register was impossible. The address operator, &, is invalid with a register variable. A variable, such as a counter, that is accessed often, is a good candidate for a register variable. With today's compilers, it is probably not necessary to suggest that using a register for a frequently accessed value is more efficient.

7 CS 110B - Rule CDClient Page The Header File // CreateDestroy.h: Interface File #ifndef _CREATEDESTROY_H_ // Note Wrapper #define _CREATEDESTROY_H_ #include <string> using namespace std; class CreateDestroy { public: CreateDestroy(const string&); // Constructor with 1 argument is called // a conversion constructor; that is, it //converts from the argument type to the class type. ~CreateDestroy(); private: string message; }; CreateDestroy* function(); // Prototype for non-member function #endif The Implementation File // CreateDestroy.cpp: Implementation File #include <iostream> #include "CreateDestroy.h" using namespace std; CreateDestroy::CreateDestroy(const string& msg) { message = msg; cout << "CONSTRUCTOR CALLED FOR " << message << endl; } CreateDestroy::~CreateDestroy() { cout << "DESTRUCTOR CALLED FOR " << message << endl; } A Client File // CDClient.cpp: Show calls for constructor and destructor #include <iostream> #include "CreateDestroy.h" using namespace std;

8 CS 110B - Rule CDClient Page CreateDestroy global("global"); // Permanent storage int main() { cout << "Beginning of main()\n"; CreateDestroy mainlocal1("main first local"); // Stack static CreateDestroy mainstatic("main static"); // Permanent storage CreateDestroy* pcreate = function(); CreateDestroy mainlocal2("main second local"); // Stack delete pcreate; cout << "End of main()\n"; return 0; } CreateDestroy* function() { cout << "Beginning of function()\n"; CreateDestroy functionlocal1("function first local"); // Stack static CreateDestroy functionstatic("function static"); // Permanent // storage CreateDestroy* pcd = new CreateDestroy("dynamic object"); // Free store CreateDestroy functionlocal2("function second local"); // Stack cout << "End of function()\n"; return pcd; } Output: Objects CONSTRUCTOR CALLED FOR global (global) Beginning of main() CONSTRUCTOR CALLED FOR main first local (mainlocal1) CONSTRUCTOR CALLED FOR main static (mainstatic) Beginning of function() CONSTRUCTOR CALLED FOR function first local (functionlocal1) CONSTRUCTOR CALLED FOR function static (functionstatic) CONSTRUCTOR CALLED FOR dynamic object (*pcd) CONSTRUCTOR CALLED FOR function second local (functionlocal2) End of function() DESTRUCTOR CALLED FOR function second local (functionlocal2) DESTRUCTOR CALLED FOR function first local (functionlocal1) CONSTRUCTOR CALLED FOR main second local (mainlocal2) DESTRUCTOR CALLED FOR dynamic object (*pcreate) End of main() DESTRUCTOR CALLED FOR main second local (mainlocal2) DESTRUCTOR CALLED FOR main first local (mainlocal1) DESTRUCTOR CALLED FOR function static (functionstatic) DESTRUCTOR CALLED FOR main static (mainstatic) DESTRUCTOR CALLED FOR global (global)

9 CS 110B - Rule CDClient Page Image of CreateDestroy object, global: global message ptr global size Stack during function(): Free Store: pcreate functionlocal2 pcd functionlocal1 function() main() mainlocal1 Stack after function(): mainlocal2 pcreate mainlocal1 main() Permanent Memory: global mainstatic functionstatic

10 CS 110B - Rule CDClient Page Note: Are these valid alternatives to line 36? You would need to make similar changes to the prototype in line CreateDestroy::CreateDestroy(const string& msg) 1. CreateDestroy::CreateDestroy(string& msg) 2. CreateDestroy::CreateDestroy(string msg) 3. CreateDestroy::CreateDestroy(const char* msg) 4. CreateDestroy::CreateDestroy(char* msg)