C language | the difference between heap and stack

1. Management style : Automatic stack management system ; The heap is controlled by the programmer , Easy to use , But it is prone to memory leakage .
2. Direction of growth : Stack extends to low address ( namely ” Downward growth ”), It's a continuous memory area ; The heap extends to higher addresses ( namely ” Growing up ”), It's a discontinuous memory area . This is because the heap management system uses a linked list to store free memory addresses , Natural discontinuity , The linked list traverses from low address to high address .
3. The size : The stack top address and the maximum capacity of the stack are predetermined by the system ( Usually the default is 1M or 10M); The size of the heap is limited by the virtual memory available in the computer system ,32 position Linux Heap memory in the system can reach 2.9G Space .
4. Store content : Stack on function call , The first thing to push in is the function argument , Then the next instruction in the calling function ( The next executable statement of a function call statement ) Press your address into , Finally, the local variables of the called function . After this call , Local variables first out of stack , Instruction address out of stack , Finally, stack balance , The program continues to run the next executable statement from this point . The heap usually stores its size in a byte in the header , Heap is used to store data whose lifetime is independent of function call , The specific content is arranged by the programmer .
5. Distribution efficiency : The stack is supported by the underlying computer : Allocate a special register to store the stack address , Pressing and exiting the stack are executed by special instructions , So it's more efficient . Heap is provided by function library , The mechanism is complex , Much less efficient than stack .
6. Distribution method : Stacks can be allocated statically or dynamically . Static allocation is done by the compiler , Such as the distribution of local variables . Dynamic allocation is made by alloca Function to request space on the stack , Automatic release after use without transfer free function . The heap can only be allocated dynamically and released manually .
7. System response after allocation : As long as the remaining stack space is larger than the requested space , The system will provide memory for the program , Otherwise, an exception prompt stack overflow is reported . The operating system maintains a linked list of free memory addresses for the heap . When the system receives the memory allocation request of the program , It will traverse the linked list to find the first heap node whose space is greater than the applied space , Then delete the node from the free node list , And the node space is allocated to the program . If there is not enough space ( Probably due to too many memory fragments ), It is possible to call system functions to increase the memory space of program data segments , In order to have a chance to allocate enough memory , Then go back . Most systems will record the memory size allocated this time at the first address of the memory space , For subsequent release functions ( Such as free/delete) Free the memory space correctly . Besides , Because the size of the heap node found may not be exactly equal to the size of the application , The system will automatically put the redundant part back into the free linked list .
8. Debris problem : There will be no fragmentation of the stack , Because the stack is an in and out queue , Before the memory block is ejected from the stack , The contents of the backward stack above it have been ejected . However, frequent requests for free operation will cause the discontinuity of heap memory space , It's a lot of debris , To reduce the efficiency of a program .

so , Heap can easily cause memory fragmentation ; Because there is no special system support , Efficiency is very low ; Because it may cause user mode and kernel mode switching , Memory requests are more expensive . So stack is the most widely used in programs , Function calls also use the stack to complete , Parameters in the call process 、 The return address 、 Stack based pointers and local variables are stored in stack mode . therefore , It is recommended to use stack as much as possible , Use heap only when allocating large or large amounts of memory space .