C ++ memory Partition

In C ++, memory is divided into five areas: heap, stack, free storage, global/static storage, and constant storage.
Stack is the storage area for variables that are automatically allocated by the compiler when necessary and clear when not needed. The variables are usually local variables and function parameters.
Heap is the memory blocks allocated by new. Their release compilers are not controlled and controlled by our applications. Generally, a new compiler corresponds to a Delete. If the programmer does not release the program, the operating system will automatically recycle it after the program is completed.
The free storage zone is the memory blocks allocated by malloc and so on. It is very similar to the heap, but it uses free to end its own life.
In the global/static storage area, global variables and static variables are allocated to the same memory. In the previous C language, global variables were divided into initialized and uninitialized ones, in C ++, there is no such distinction. They share the same memory zone.
Constant storage area, which is a special storage area. It stores constants and cannot be modified (of course, you can modify them by improper means, and there are many methods)
Clearly differentiate stack and stack
On the BBS, the distinction between heap and stack seems to be an eternal topic. It can be seen that beginners are often confused about this, so I decided to take him first.
First, let's take an example:
Void F () {int * P = new int [5];}
This short sentence contains the heap and stack. When we see new, we should first think that we allocated a heap memory. What about the pointer P? It allocates a stack memory, so this sentence means that the stack memory stores a pointer P pointing to a heap memory. The program will first determine the size of memory allocated in the heap, then call operator new to allocate the memory, then return the first address of the memory, and put it into the stack, the assembly code in vc6 is as follows:
00401028 push 14 h
0040102a call operator new (00401060)
0040102f add ESP, 4
00401032 mov dword ptr [ebp-8], eax
00401035 mov eax, dword ptr [ebp-8]
00401038 mov dword ptr [ebp-4], eax
Here, we have not released the memory for simplicity, So how should we release it? Is it delete p? Australia, the error should be "Delete [] P" to tell the compiler: I deleted an array and vc6 will release the memory based on the cookie information.
Well, let's go back to our topic: What is the difference between stack and stack?
The main differences are as follows:
1. Different management methods;
2. Different space sizes;
3. Whether fragments can be generated is different;
4. Different Growth directions;
5. Different allocation methods;
6. Different Allocation Efficiency;
Static is used to control the storage and visibility of variables.
When a variable defined in a function is executed to its definition, the compiler allocates space for it on the stack, the space allocated by the function on the stack is released at the end of the function execution. This creates a problem: If you want to save the value of this variable in the function to the next call, how to implement it? The easiest way to think of is to define a global variable, but defining a global variable has many disadvantages, the most obvious drawback is that the access range of the variable is broken (so that the variables defined in this function are not controlled by this function ).

A Data Object is required to serve the entire class rather than a specific object, and the encapsulation of the class is not damaged. That is, the member is required to be hidden inside the class and invisible to the outside world.

Static internal mechanism:
Static data members must exist at the beginning of the program. Because the function is called during the running of the program, static data members cannot allocate space and initialize it in any function.
In this way, there are three possibilities for its space allocation. One is the header file of the class's external interface, where there is a class declaration; the other is the internal implementation of the class definition, there is a member function definition for the class, and the third is the global data description and definition before the main () function of the application.
Static data members must actually allocate space, so they cannot be defined in the class declaration (only data members can be declared ). The class declaration only declares the "size and specification" of a class and does not actually allocate memory. Therefore, it is wrong to write a definition in the class declaration. It cannot be an external definition of the class declaration in the header file, because it will duplicate the definition in multiple source files that use the class.
Static is introduced to inform the compiler that the variables are stored in the static storage area of the program rather than the stack space.
Data members are initialized sequentially according to the sequence in which they appear. Note that when static members are nested, ensure that the nested members have already been initialized. The order of cancellation is the reverse order of initialization.

Static advantages:
Memory can be saved because it is public to all objects. Therefore, for multiple objects, static data members only store one object for sharing. The value of a static data member is the same for each object, but its value can be updated. You only need to update the value of the static data member once to ensure that all objects have the same value after the update, which improves the time efficiency.

When referencing static data members, use the following format:
<Class name >:: <static member name>
If the access permission of the static data member is allowed (that is, the Public Member), in the program, according to the above format
To reference static data members.

PS:
(1) The static member function of the class belongs to the entire class rather than the class object, so it does not have the this pointer, which leads
It only supports the static data and static member functions of the category.
(2) static member functions cannot be defined as virtual functions.
(3) Since static members are declared in the class and operated outside of the class, it is somewhat special to perform the address fetch operation on them.
The variable address is a pointer to its data type, and the function address type is a "nonmember function pointer ".

(4) because the static member function does not have the this pointer, it is almost equivalent to the nonmember function.
This creates an unexpected benefit: Being a callback function allows us to combine C ++ and C-based X W
The indow system is combined and successfully applied to the thread functions.
(5) Static does not increase the space-time overhead of the program. On the contrary, it shortens the access of the subclass to the static members of the parent class.
Time, saving sub-class memory space.
(6) Add the keyword "static" before <definition or description> to the static data member.
(7) static data members are stored statically, so they must be initialized.
(8) static member Initialization is different from general data member initialization:
Initialization is performed in the external class without static before, so as to avoid confusion with general static variables or objects;
During initialization, the access permission control characters private and public of the member are not added;
During initialization, the scope operator is used to indicate the class to which it belongs;
So we can get the format of static data member initialization:
<Data type> <class name >:< static data member name >=< value>
(9) to prevent the influence of the parent class, you can define a static variable of the same as the parent class in the subclass to avoid the influence of the parent class. Here, we need to note that static members are shared by the parent class and subclass, but we have repeatedly defined static members. Will this cause errors? No, our compiler uses a wonderful method: Name-mangling is used to generate a unique flag.