[Turn]c++ static member function summary

A static member of a class is a love-hate trait. I decided to summarize the knowledge points of static class members so that I would not be passive on such issues in future interviews.
Static class members include both static data members and static function members.

A static data member:

The declaration of a data member in the class body is preceded by the static keyword, which becomes a data member of that class. As with other data members, static data members also adhere to public/protected/private access rules. At the same time, static data members have the following characteristics:

1. Definition of a static data member.
A static data member is actually a global variable in a class domain. Therefore, the definition of a static data member (initialization) should not be placed in the header file.
It is defined in the same way as a global variable. Examples are as follows:

Xxx.h file
Class base{
Private
The static const int _i;//declares that standard C + + supports an ordered type initialization in the class body, but VC6 is not supported.
};

Xxx.cpp file
const int base::_i=10;//is not subject to private and protected access restrictions when defined (initialized).

Note: Do not attempt to define (initialize) static data members in the header file. In most cases, doing so would cause a duplicate definition of such an error. Even adding #ifndef #define #endif或者 #pragma once.

2. Static data members are shared by all objects of the class, including objects of the class's derived classes. That is, a derived class object shares a static data member of a base class with a base class object. Examples are as follows:
Class base{
Public:
static int _num;//Declaration
};
int base::_num=0;//The true definition of a static data member

Class Derived:public base{
};

Main ()
{
base A;
Derived B;
a._num++;
cout<< "base class static data number _num is" <<a._num<<endl;
b._num++;
cout<< "derived class static data number _num is" <<b._num<<endl;
}
The result is 1, 2; a static data member is shared by the derived class and the base class.

3. A static data member can be an optional parameter to a member function, while a normal data member may not. Examples are as follows:
Class base{
Public:
static int _staticvar;
int _var;
void foo1 (int i=_staticvar);//correct, _staticvar as static data member
void Foo2 (int i=_var);//error, _var as normal data member
};

4.★ the type of a static data member can be the type of the owning class, but ordinary data members are not. A normal data member can only be declared as a pointer or reference to the owning class type. Examples are as follows:

Class base{
Public:
Static base _object1;//correct, still data member
Base _object2;//Error
Base *pobject;//Correct, pointer
Base &mobject;//Correct, reference
};

5.★ This feature, I don't know if it's a feature in standard C + +, or VC6 own feature.
The value of a static data member can be legitimately changed in a const member function. Examples are as follows:

Class base{
Public
Base () {_i=0;_val=0;}

mutable int _i;
static int _staticval;
int _val;
void Test () Const{//const member function

_i++;//correct, mutable data member
_staticval++;//correct, static data member
_val++;//Error

}
};
int base::_staticval=0;
The const member function is used only to decorate the this pointer.
Because the static data member is the entire class public, the compiler does not add the this pointer.
Two, static member functions
Static member functions There is nothing too good to say.

1. The address of a static member function can be stored using a normal function pointer, whereas a normal member function address needs to be stored with a class member function pointer. Examples are as follows:
Class base{
static int func1 ();
int Func2 ();
};

Int (*PF1) () =&base::func1;//normal function pointer
Int (base::* pf2) () =&base::func2;//member function pointer


2. Static member functions can not invoke non-static members of a class. Because the static member function does not contain the this pointer.

3. Static member functions cannot be declared as virtual, const, or volatile functions at the same time. Examples are as follows:
Class base{
Virtual static void Func1 ();//Error
static void Func2 () const;//error
static void Func3 () volatile;//error
};


The last thing to say is that static members can be accessed independently, that is, without creating any object instances.

[Turn]c++ static member function summary