The difference between heap and stack (Turning countless articles) and turning countless articles

The difference between heap and stack (Turning countless articles) and turning countless articles
I. prerequisites-program memory allocation

The memory occupied by a C/C ++ compiled program is divided into the following parts:

Example Program

This is written by a senior. It is very detailed.

// Main. cppint a = 0; // global initialization zone char * p1; // global uninitialized Zone 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 .}

Ii. Theoretical knowledge of heap and stack 2.1 Application Method

Stack: automatically assigned 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: requires the programmer to apply for and specify the size. In c, the malloc Function

For example, p1 = (char *) malloc (10 );

Use the new operator in C ++: p2 = new char [10];

But 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

The stack is automatically allocated by the system, which is faster. But programmers cannot control it.
The heap is the memory allocated by new, which 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 piece of memory directly 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[] = "aaaaaaaaaaaaaaa";char *s2 = "bbbbbbbbbbbbbbbbb";

Aaaaaaaaaaa is assigned a value at runtime, while bbbbbbbbbbbbb is determined at 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 <stdio.h>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],cl11:   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 and then reads the characters according to edx, which is obviously slow.

Conclusion 2.7

The difference between stack and stack can be seen in the following metaphor:
Using Stacks is like eating at a restaurant, just ordering food (sending an application), paying for it, and eating (using it). If you are full, you can leave, without having to worry about the preparation work, such as cutting and washing dishes, as well as the cleaning and tail work such as washing dishes and flushing pots, his advantage 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. (Classic !)