Professional Documents
Culture Documents
Pi19404
November 24, 2013
Contents
Contents
C++ Static Members
0.1 Introduction . . . . . . . . . . . . . . . 0.2 Storage Access Specifiers . . . . 0.2.1 Static Storage Specifier 0.2.2 Static Member function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3
3 3 4 8
2 | 11
A storage class specifier is used to refine the declaration of a variable, a function, and parameters. A storage class specifier do not specify the scope but combined with scope to determine the storage duration and visibility of items. The storage class specifier used within the declaration determines whether:
The object has internal, external, or no linkage The object can be referenced throughout a program or only
within the function, block, or source file where the variable is defined
- In C / C++ there are 4 different storage classes available: auto,extern,register,static,mutable How these specifiers affect objects depend also on the scope in which they appear. Storage class specifiers are keywords you can use in declarations to control storage duration and linkage.
3 | 11
The linkage determines if declaration in different scopes can refer to the same object. - Storage class specifiers tell compiler the duration and visibility of the variables or objects declared, as well as, where the variables or objects should be stored.
Class members can be declared using the storage class specifier static in the class member list The declaration of a static data member in the member list of a class is not a definition. It must be defined outside the class declaration. When you declare an object of a class having a static member, the static member is not part of the class object.
class X { static int f; void inc() { f=f+1; } }; int main() { X x1,x2; x1.inc(); x2.inc(); cout << x1.f << ":" << x2.f << endl; }
Only one copy of the static member is shared by all objects of a class in a program.
4 | 11
You can access a static member of a class by qualifying the class name using the :: (scope resolution) operator
class X { public: static int f; void inc1() { f=f+1; } }; int X::f=0; int main() { X x1,x2; x1.inc1(); x2.inc1(); //accessing static member cout << x1.f << ":" << x2.f << ":" << X::f << endl; }
Once you define a static data member, it exists even though no objects of the static data members class exist.
class X { public: static int fx1; void inc1() { fx1=fx1+1; } }; int X::fx1=10; int main() { //accessing static member cout << X::fx1 << endl; }
The progam will print value 10.
5 | 11
class X { public: static int fx1; void inc1() { } }; int X::fx1=1; //initializing the static data member while defining it
A static data member can also be initialized while declaring the class only if it is also declared as const.
class X { public: const static int fx1=1; //declared as const static }; const int X::fx1; //defined as const nt int main() { }
class X { public:
6 | 11
int main() { class X{ //class X is a local class static int fx1; }; int X::fx1=1;
static data member can be of any type except void or void qualified with const or volatile.
class X{ public: static void fx1() const; //this will give a erro X(){}; };
Static data members and their initializers can access other static private and protected members of their classes
class X{ public: static int static int static int static int
7 | 11
static int f5; static int f6; int f7; static int f(){return 100;} X():f7(100){}; }; X x; int X::f1=10; int X::f2=X::f1; //using f1 to initialize f2 int X::f3=X::f();//initialized using static function int X::f4=x.f1; //intialized with object data member int X::f5=x.f(); //initialized with function from object int X::f6=x.f7;//initialized using non static member of object
You cannot have static and nonstatic member functions with the same names and the same number and type of arguments.
class X{ public: static int a; static int inc() { a=a+1; } int inc() //this will give an error { } X(){}; };
Like static data members, you may access a static member function of a class without the object of the class
8 | 11
a=a+1; } X(){}; }; int X::a=0; int main() { cerr << X::inc() << endl; }
class X{ public: int b; static int a; static int inc() { a=this->b; //this will give an error a=a+1; } X(){}; }; X obj; int X::a=0; int main() { cerr << X::inc() << endl; }
class X{ public: int b; static int a; const volatile static int inc() //this is allowed { a=a+1; } X(){}; };
9 | 11
class X{ public: int b; static int a; virtual static int inc() //this will given an error { a=a+1; } X(){}; };
A static member function can access only the names of static members, enumerators, and nested types of the class in which it is declared
class X{ public: int b; static int a; enum mode{a1,a2,a3}; static int inc() { return a1; //this is allowed since it is of enum type } X(){}; };
A static member function cannot access the non static members of the class or base class class X public: int b; static int a; enum modea1,a2,a3; static int inc() return b;//this will give an error X(); ; Static data members of class have extern linkage,they can be accessed and duration is the lifetime of the program. This can be used for class members that are required to be used in all the files and its value retained across all the files, for example logging class,monitoring class etc.
If a class object is defined as static,then this serves as a static storage access specifier,which defines the scope of the item to be file scope,duration is program execution and linkage is internal linkage.
10 | 11
file :a1.cpp class X{ public: int x; }; static X x1; int b() { x1.x=100; return x1.x; //returning value of member of static object } file :a2.cpp extern int b(); class X{ public: int x; }; static X x1; int main() { x1.x=101; int ff=b(); cerr << x1.x << ":" << ff << endl; //value printed is 101:100 }
11 | 11