Summary of the static keyword in C + +

　　The static of C + + has two usages: static in process-oriented programming and static in object-oriented programming. The former applies to ordinary variables and functions, and does not involve classes; the latter mainly describes the role of static in classes.

1. Static for process design
1.1 Static global variables
Before the global variable, the variable is defined as a static global variable, plus the keyword static. Let's first give an example of a static global variable, as follows:
Example 1
#include <iostream.h>
VOID Fn ();
static int n; Defining static global Variables
void Main ()
{
n=20;
cout<<n<<endl;
FN ();
}

VOID Fn ()
{
n++;
cout<<n<<endl;
}
Static global variables have the following characteristics:
? The variable allocates memory in the global data area;
? Uninitialized static global variables are automatically initialized by the program to 0 (the value of the automatic variable is random unless it is explicitly initialized);
? A static global variable is visible in the entire file that declares it, and is invisible outside of the file;

Static variables allocate memory in the global data area, including the static local variables that will be mentioned later. For a complete program, the distribution in memory is as follows:
Code Area
Global Data area
Heap Area
Stack area
The dynamic data generated by new in the general program is stored in the heap area, and the automatic variables inside the function are stored in the stack area. Automatic variables generally free up space as the function exits, and static data (even static local variables inside the function) is stored in the global data area. The data in the global data area does not free up space because of the function's exit. The attentive reader may find that the code in Example 1 will "static int n; Define static global variable "to " int n; Define the global variables. The program is still functioning normally. It is true that defining global variables allows for the sharing of variables in files, but there are also the following benefits of defining static global variables:
? Static global variables cannot be used by other files;
? Variables of the same name can be defined in other files, and no conflicts will occur;

You can change the example code above to read as follows:
Example 2
File1
#include <iostream.h>
VOID Fn ();
static int n; Defining static global Variables
void Main ()
{
n=20;
cout<<n<<endl;
FN ();
}

File2
#include <iostream.h>
extern int n;
VOID Fn ()
{
n++;
cout<<n<<endl;
}
Compile and run Example 2, and you will see that the above code can be compiled separately, but there is an error at run time. Try to "static int n; Define static global variable " to " int n; Define Global Variables "
compile and run the program again, and carefully understand the difference between "global variables" and "Static global variables".

1.2. Static local variables
Before local variables, add the keyword static, The variable is defined as a static local variable. Let's first give an example of a static local variable, as follows:
//example 3
#include <iostream.h>
void fn ();
void Main ()
{
  fn ();
  FN ();
  FN ();
}
void fn ()
{
  static n=10;
  cout<<n<<endl;
 n++;
}
Typically, a variable is defined in the body of the function that allocates stack memory to the local variable whenever the program runs to the statement. However, as the program exits the function body, the system will retract the stack memory, and the local variables are invalidated accordingly. But sometimes we need to save the values of the variables between the two calls. The usual idea is to define a global variable to implement. In this way, the variables are no longer part of the function itself, and are no longer only controlled by the functions, which inconvenience the maintenance of the program. A
static local variable can solve this problem. Static local variables are saved in the global data area, not in the stack, and each time the value is persisted to the next call until the next time the new value is assigned. The
static local variable has the following characteristics:
?  The variable allocates memory in the global data area,
?  The static local variable is first initialized when the program executes to the declaration of the object, and subsequent function calls are no longer initialized; ( initialize only once!!! )
?  Static Local variables are typically initialized at the declaration and, if not explicitly initialized, are automatically initialized by the program to 0;
?  It always resides in the global data area until the end of the program runs. But its scope is a local scope, and when the function or block of statements defining it ends, its scope ends;

1.3 Static functions
The function is defined as a static function by adding the static keyword before the return type of the function. A static function differs from a normal function in that it can only be seen in the file that declares it and cannot be used by other files.
Examples of static functions:
Example 4
#include <iostream.h>
static void Fn ();//Declaration of a function
void Main ()
{
FN ();
}
VOID FN ()//define static functions
{
int n=10;
cout<<n<<endl;
}
Benefits of defining static functions:
? Static functions cannot be used by other files;
? Other files can define a function of the same name, and no conflict will occur;

Second, the object-oriented static keyword (the static keyword in the Class)
2.1 Static data members
Precede the declaration of a data member within a class with the keyword static, which is a static data member within the class. Give an example of a static data member first.
Example 5
#include <iostream.h>
Class Myclass
{
Public
Myclass (int a,int b,int c);
void Getsum ();
Private
int a,b,c;
static int sum;//declares a data member at rest
};
int myclass::sum=0;//to define and initialize a static data member

Myclass::myclass (int a,int b,int c)
{
this->a=a;
this->b=b;
this->c=c;
Sum+=a+b+c;
}

void Myclass::getsum ()
{
cout<< "sum=" <<Sum<<endl;
}

void Main ()
{
Myclass M (a);
M.getsum ();
Myclass N (4,5,6);
N.getsum ();
M.getsum ();

}
, it can be seen that static data members have the following characteristics:
?  for non-static data members, each class object has its own copy. Static data members are treated as members of the class. Regardless of how many objects of this class are defined, static data members have only one copy in the program and are shared by all objects of that type. In other words, a static data member is common to all objects of that class. For multiple objects of this class, static data members are allocated only once for all objects to be shared. Therefore, the value of a static data member is the same for each object, its value can be updated, and the
?  static data member is stored in the global data area. Static data members are defined when they are allocated space, so they cannot be defined in a class declaration. In Example 5, the statement int myclass::sum=0; is a static data member;
?  static data members and normal data members follow public,protected,private access rules;
?  Because static data members allocate memory in the global data area, all object shares of this class are shared, so it does not belong to a particular class object, and its scope is visible when no class object is produced, that is, we can manipulate it without producing an instance of the class;
?  Static data member initialization differs from general data member initialization. Static data member initialization is in the form of
data type >< class name >::< static data member name >=< value >
static data member of the?  class has two access forms:
Class object name >.< static data member name, or class type name >::< static data member name
If the access rights of a static data member are allowed (that is, members of public), you can refer to static data members in the program in the format described above;
?  static data members are used primarily when each object has the same property. For example, for a deposit class, the interest is the same for each instance. Therefore, interest should be set as a static data member of the deposit class. There are two benefits, first, regardless of how many deposit class objects are defined, the interest data members share the memory allocated in the global data area, thus saving storage space. Second, once the interest needs to change, as long as the change, the interest of all the deposit classes changed over;
?  using static data members has two advantages over global variables:
1.  static data members do not enter the program's global namespace. Therefore, there is no possibility of conflicts with other global names in the program;
2.  can implement information hiding. A static data member can be a private member, while a global variable cannot;

2.2 Static member functions
As with static data members, we can also create a static member function that serves the entire service of a class rather than a specific object of a class. Static member functions, like static data members, are internal implementations of the class and are part of the class definition. Ordinary member functions generally imply a this pointer, which points to the object of the class itself, because ordinary member functions are always specific to the specific object of a class. Typically, this is the default. such as the function fn () is actually THIS->FN (). However, compared to a normal function, a static member function does not have the this pointer because it is not associated with any object. In this sense, it cannot access non-static data members that belong to a class object, nor can it access a non-static member function, which only calls the rest of the static member functions. Here is an example of a static member function.
Example 6
#include <iostream.h>
Class Myclass
{
Public
Myclass (int a,int b,int c);
static void Getsum ();
Private
int a,b,c;
static int sum;//declares a data member at rest
};
int myclass::sum=0;//to define and initialize a static data member

Myclass::myclass (int a,int b,int c)
{
this->a=a;
this->b=b;
this->c=c;
Sum+=a+b+c; Non-static member functions can access static data members
}

void Myclass::getsum ()//static member function implementation
{
cout<<a<<endl; Error code, a non-static data member
cout<< "sum=" <<Sum<<endl;
}

void Main ()
{
Myclass M (a);
M.getsum ();
Myclass N (4,5,6);
N.getsum ();
Myclass::getsum ();
}
For static member functions, you can summarize the following points:
? A function definition that appears outside the class body cannot specify a keyword static;
? Static members can be accessed from one another, including static member functions that access static data members and access static member functions;
? Static member functions and static data members can be accessed arbitrarily by non-static member functions;
? Static member functions cannot access non-static member functions and non-static data members;
? Because there is no additional overhead for this pointer, the static member function has a slight increase in speed compared to the global function of the class;
? Call a static member function, which can be accessed with the member access operator (.) and (-) call a static member function for an object of a class or pointer to a class object, or you can use the following format directly:
Class name >::< static member function name > (parameter table)
Invokes the static member function of the class.

Summary of the static keyword in C + +