Program memory allocation

The memory occupied by C/C ++ compiled programs is divided into the following parts:
1. STACK: the compiler automatically allocates and releases the stack, stores the function parameter values, and values of local variables. Memory Allocation is continuous, similar

Normally, if we do not know the stack, think of it as an array, and its memory allocation is continuously allocated, that is, the allocated memory is in a continuous memory area. when we declare a variable, the compiler will automatically allocate memory at the end of the current stack.
2. Heap: Generally, it is assigned and released by the programmer. If the programmer does not release the heap, it may be recycled by the OS at the end of the program. Note that it is different from the heap in the data structure. The allocation method is similar to the linked list. The distribution in the memory is not consecutive. They are linked by pointers of memory blocks in different regions. once a node is disconnected from the chain, we need to release the disconnected node from the memory.
3. Global zone (static): the storage of global variables and static variables is put together, and the initialized global variables and static variables are stored in one area, uninitialized global variables and uninitialized static variables are located in another adjacent area. After the program ends, the system is released.
4. Text constant area: the constant string is placed here, and is released by the system after the program ends.
5. program code area: stores the binary code of the function body.

Example:

Int A = 0; // global initialization Zone
Char * P1; // not initialized globally
Main ()
{
Int B; // Stack
Char s [] = "ABC"; // Stack
Char * P2; // Stack
Char * P3 = "123456"; // 123456 \ 0 is in the constant zone, and P3 is in the stack.
Static int C = 0; // global (static) initialization Zone
P1 = (char *) malloc (10 );
P2 = (char *) malloc (20); // The allocated 10-byte and 20-byte areas are in the heap area.
Strcpy (P1, "123456"); // 123456 \ 0 is placed in the constant area, and the compiler may optimize it into a place with the "123456" pointed to by P3.
}

Char C; // stack allocation
Char * P = new char [3]; // allocated on the heap and assigned the address to P;

 

When the compiler encounters the first instruction, it calculates its size and finds that the current stack space is larger than the space to be allocated. If the stack space is larger than the applied space, therefore, we will allocate memory space for it. Note: In this case, the internal space is allocated continuously, which is then allocated after the last allocation. if the size of the stack space is smaller than the size of the applied space, the system will reveal Stack Overflow and provide corresponding exception information. when the compiler encounters the Second instruction, P is allocated on the stack, so the internal space allocated for P is the same as the method above. But when the new keyword is encountered, the compiler knows that, this is the dynamic memory space applied by the user, so it will be transferred to the heap to find space for allocation. note: the memory space on the heap is not consecutive. It is connected by the corresponding linked list to the internal block of its space partition. Therefore, after receiving the specified memory space allocated, it does not immediately allocate the corresponding space for it. Instead, it needs to calculate the required space and then refresh the entire column (that is, the node of the entire chain ), allocate the memory block for the first time. finally, the first address of the character array allocated on the heap is assigned to P ., at this time, we know that P now stores the first address of the character array applied in the heap, that is, the address of the Array Applied in the heap is now assigned to the pointer Variable P applied on the stack.

Note: When the memory space applied for on the stack is out of the scope of the variable, the system will automatically recycle the space and apply for the space on the stack, when the corresponding scope is available, we need to explicitly call Delete to release the applied memory space. If we do not need to release the space in time, as memory fragments increase, our actual memory space will become fewer and fewer, I .e., there will be more and more isolated memory blocks. here, we know that the memory area in the heap is not continuous, and the valid memory area is connected through the linked list pointer. If we apply for a memory, this memory block will be disconnected from the continuous (linked list) memory block. If we do not release it in time after use, then it will be isolated, because there is no pointer pointing to it, so this area will become memory fragments, so after using the dynamically allocated memory (applied through new, delete it explicitly. remember to do this.

Ii. Theoretical knowledge of heap and stack

2.1 Application Method
STACK: automatically allocated by the system. For example, declare a local variable int B in the function; the system automatically opens up space for B in the stack.
Heap: the programmer must apply for it and specify the size. In C, the malloc function is: for example, P1 = (char *) malloc (10 ); in C ++, use the new operator such as P2 = (char *) malloc (10). Note that P1 and P2 are in the stack.

2.2 system response after application
STACK: as long as the remaining space of the stack exceeds the applied space, the system will provide the program with memory. Otherwise, an exception will be reported, prompting stack overflow.
Heap: First, you should know that the operating system has a linked list that records idle memory addresses. When the system receives a program application, it will traverse the linked list, find the heap node with the first space greater than the requested space, delete the node from the idle node linked list, and allocate the space of the node to the program. In addition, for most systems, the size of the allocation will be recorded at the first address in the memory space, so that the delete statement in the code can correctly release the memory space. In addition, because the size of the heap node is not necessarily equal to the applied size, the system automatically places the excess part in the idle linked list.

2.3 Application size limit
STACK: in windows, a stack is a data structure extended to a low address and a continuous memory area. This statement indicates that the stack top address and the maximum stack capacity are pre-defined by the system. In Windows, the stack size is 2 MB (OR 1 MB, in short, it is a constant determined during compilation. If the requested space exceeds the remaining space of the stack, overflow will be prompted. Therefore, the space available from the stack is small.
Heap: the heap is a data structure extended to the high address and a non-sequential memory area. This is because the system uses the linked list to store the idle memory address, which is naturally discontinuous, And the traversal direction of the linked list is from the low address to the high address. The heap size is limited by the valid virtual memory in the computer system. It can be seen that the space obtained by the heap is flexible and large.

2.4 comparison of application efficiency:
STACK: the stack is automatically allocated by the system, and the speed is fast. But programmers cannot control it.
Heap: Memory allocated by new. It is generally slow and prone to memory fragments. However, it is most convenient to use.
In addition, in windows, the best way is to use virtualalloc to allocate memory. Instead of heap or stack, it is to reserve a fast memory in the address space of the process, although it is the most inconvenient to use. However, it is fast and flexible.

Storage content in 2.5 heap and stack
STACK: when calling a function, the first entry to the stack is the address of the next instruction in the main function (the next executable statement in the function call statement), and then the parameters of the function, in most C compilers, parameters are written from right to left into the stack, followed by local variables in the function. Note that static variables are not included in the stack. When the function call ends, the local variable first goes out of the stack, then the parameter, and the top pointer of the stack points to the address of the initial storage, that is, the next instruction in the main function, where the program continues to run.
Heap: Generally, the heap size is stored in one byte in the heap header. The specific content in the heap is arranged by the programmer.

2.6 comparison of access efficiency
Char S1 [] = "aaaaaaaaaaaaa ";
Char * S2 = "bbbbbbbbbbbbbbbbb ";
Aaaaaaaaaaa is assigned a value at the runtime;
Bbbbbbbbbbbbb is determined during compilation;
However, in future access, the array on the stack is faster than the string pointed to by the pointer (such as the heap.
For example:
# Include
Void main ()
{
Char A = 1;
Char C [] = "1234567890 ";
Char * P = "1234567890 ";
A = C [1];
A = P [1];
Return;
}
Corresponding assembly code
10: A = C [1];
00401067 8A 4D F1 mov Cl, byte PTR [ebp-0Fh]
0040106a 88 4D FC mov byte PTR [ebp-4], Cl
11: A = P [1];
0040106d 8B 55 EC mov edX, dword ptr [ebp-14h]
00401070 8A 42 01 mov Al, byte PTR [edX + 1]
00401073 88 45 FC mov byte PTR [ebp-4], Al
The first type reads the elements in the string directly into the CL register, while the second type reads the pointer value into EDX. Reading the characters based on edX is obviously slow.

2.7 summary:
The difference between stack and stack can be seen from the following metaphor: using Stack is like eating at a restaurant, just ordering food (sending an application), paying for it, and eating (using it ), when you are full, you don't have to worry about the preparation work, such as cutting and washing dishes, washing dishes, and so on. His advantage is that it is fast, but his degree of freedom is small. Using heap is like making your favorite dishes. It is troublesome, but it suits your taste and has a high degree of freedom.

In addition, during function calling, a series of operations will be performed on the stack to retain the site and transmit parameters. The stack space is limited. The default value of VC is 2 MB. When the stack is not enough, it is generally because the program has allocated a large number of arrays and recursive function layers too deep. It is important to know that when a function is returned after calling, it will release all the stack space of the function. The stack is automatically managed by the compiler, so you don't have to worry about it. Heap dynamically allocates memory, and you can allocate a large amount of memory. However, poor use may cause memory leakage. In addition, frequent malloc and free will generate memory fragments (a bit similar to disk fragments), because C searches for matching memory when allocating dynamic memory. Stack does not produce fragments. Accessing data on a stack is faster than accessing data on a stack through a pointer. Generally, stack is the same as stack, that is, stack, and heap. The stack is first imported and then output, and is generally grown from a high address to a low address.

Program memory allocation