Stack and stack differences [summary]

1.1 Memory Allocation:

Heap: Generally, it is assigned to the programmer for release. If the programmer does not release the program, 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 keywords that may be used are new, malloc, delete, and free.

Stack: The Compiler (compiler) automatically allocates the release, stores the parameter values of the function, and values of local variables. The operation method is similar to the stack in the data structure.

1.2Application Method:

Heap: The programmer must apply and specify the size. In C, the malloc function is like p1 = (char *) malloc (10). In C ++, the new operator is used. But note that P1 and P2 are in the stack. Because they can still be considered as local variables.

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.

1.3System response:

Heap: The operating system has a linked list that records idle memory addresses. When the system receives a program application, it traverses the linked list to find the first heap node with a 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.

Stack: As long as the remaining stack space is larger than the requested space, the system will provide the program with memory. Otherwise, an exception will be reported, prompting stack overflow.

1.4Size limit:

Heap: It refers to the data structure extended to the high address, and is 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.

Stack: In windows,
Stack is a data structure extended to a low address and a continuous memory area. This sentence means that the top stack address and the maximum stack capacity are pre-defined by the system. In windows, the stack size is fixed (a constant determined during compilation). If the requested space exceeds the remaining space of the stack, overflow is displayed. Therefore, the space available from the stack is small.

1.5Efficiency:

Heap: It 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, it is neither in the heap nor in the stack. It is directly stored in the address space of the process, although it is the most inconvenient to use. However, it is fast and flexible.

Stack: Automatically assigned by the system, which is faster. But programmers cannot control it.

1.6Content storage:

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.

Stack: The first function to be pushed to the stack during function calling isNext instruction in the main function(The next executable statement of the function call statement) is the address of each function.ParametersIn most C compilers, parameters are written from right to left into the stack, followedLocal variable. Note:
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.

1.7Access efficiency:

Heap: Char * S1 = "Hellow word"; determined during compilation;

Stack: Char S1 [] = "Hellow word"; it is assigned a value at runtime. Using arrays is faster than using pointers, because pointers need to be transferred using the edX register in the underlying assembly, and arrays can be directly read on the stack.

Summary

1. Static variables are not included in the stack.

2. stacks are automatically allocated and released by the compiler. The stack stores local variables and parameters. After a function call is completed, the local variables first go out of the stack and then the parameters.

3. arrays are faster than pointers, because pointers need to be transferred in the underlying assembly using the edX register, while arrays are directly read on the stack.

4. The heap is allocated and released by the programmer through commands such as new, malloc, free, and delete. If the programmer does not release the program, there may be OS recycling at the end of the program.

5. The heap is the memory allocated by new, which is slow. The stack is automatically allocated by the system, which is fast.

6. For example, an array stored in the stack is assigned a value at runtime. The pointer data in the heap is determined during compilation.

Appendix:

I. In C, there are several storage areas

1. Stack-automatically allocated and released by the compiler
2. Heap-generally 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.
3. in the global zone (static zone), global variables and static variables are stored in one partition, and initialized global variables and static variables are stored in one partition, uninitialized global variables and uninitialized static variables are in another adjacent area. -Release after the program ends
4. There is also a special place to place constants. -Release after the program ends

The variables defined in the function body are usually on the stack. The memory allocated by using malloc, calloc, realloc, and other functions is on the stack. All functions define a global volume in vitro. After the static modifier is added, all functions are stored in the global zone (static zone) no matter where they are located ), static variables defined by all functions in vitro are valid in this file and cannot be used in other files. Static variables defined in the function body are valid only in this function. In addition, strings such as "adgfdf" in the function are stored in the constant area. For example:

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

2. In C ++, the memory is divided into five areas: heap, stack, free storage, global/static storage, and constant storage.
1. Stack,It is the storage area of variables that are automatically allocated by the compiler when necessary and clear when not needed. The variables are usually local variables and function parameters.
2. heap,It is the memory blocks allocated by new. Their release compiler is not controlled and controlled by our application. Generally, a new one corresponds to a Delete. If the programmer does not release the program, the operating system will automatically recycle it after the program is completed.
3. free storage zone,It 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.
4. Global/static storage ZoneGlobal variables and static variables are allocated to the same memory. In the previous C language, global variables were divided into initialized and uninitialized, in C ++, there is no such distinction. They share the same memory zone.
5. Constant storage area,This is a special storage area where constants are stored and cannot be modified (you can also modify them through improper means)

Iii. Relationship and difference between stack and stack
Specifically, modern computers (serial execution mechanisms) directly support the stack data structure at the bottom of the Code. This is reflected in the fact that there are dedicated registers pointing to the address of the stack, and dedicated machine commands to complete the operations of data in and out of the stack. This mechanism is characterized by high efficiency and limited data types supported by systems such as integers, pointers, and floating point numbers. It does not directly support other data structures. Due to the characteristics of stack, the use of stack is very frequent in the program. The call to the subroutine is done directly using the stack. The call command of the machine implicitly pushes the return address into the stack, and then jumps to the subprogram address. The RET command in the subprogram implicitly pops up the return address and jumps from the stack. The automatic variables in C/C ++ are examples of using stacks directly, which is why when the function returns, the function'sAutomatic Variable auto-Failure.

Unlike the stack, the stack data structure is not supported by the system (whether a machine system or an operating system), but provided by the function library. The basic malloc/realloc/free function maintains an internal heap data structure. When the program uses these functions to obtain new memory space, this function first tries to find available memory space from the internal heap, if there is no available memory space, the system calls are used to dynamically increase the memory size of the program data segment. The newly allocated space is first organized into the internal heap and then returned to the caller in an appropriate form. When the program releases the allocated memory space, this memory space is returned to the internal Heap Structure and may be processed properly (for example, merged into a larger idle space with other idle space ), it is more suitable for the next memory allocation application. This complex allocation mechanism is actually equivalentBuffer Pool allocated by memory(Cache), the use of this mechanism has the following reasons:
1. system calls may not support memory allocation of any size. Some system calls only support fixed memory requests and their multiples (allocated by PAGE). This will cause a waste for a large number of small memory categories.
2. System Call memory application may be expensive. System calls may involve switching between user and core states.
3. Unmanaged memory allocation can easily cause memory fragmentation when a large amount of complex memory is allocated and released.

Stack and stack comparison
From the above knowledge, we can see that stack is a function provided by the system, featuring fast and efficient. Its disadvantage is its limitation and data is not flexible. Stack is a function provided by the function library, featuring flexibility and convenience, data is widely adapted, but the efficiency is reduced. The stack is the system data structure, which is unique for processes/Threads. The heap is the internal data structure of the function library, which is not necessarily unique. Memory allocated by different heaps cannot be operated on each other. Stack space is divided into static allocation and dynamic allocation. Static allocation is completed by the compiler, such as automatic variable allocation. Dynamic Allocation is completed by the alloca function. The stack does not need to be released dynamically (automatically), so there is no release function. For the sake of portable programs, dynamic stack allocation is not encouraged! Heap space allocation is always dynamic. Although all the data space will be released back to the system at the end of the program, the memory/
Releasing memory matching is the basic element of a good program.

1. fragmentation: For the heap,Frequent new/delete operations will inevitably lead to memory disconnections, resulting in a large number of fragments, reducing program efficiency.. For the stack, this problem will not exist, because the stack is an advanced and outgoing queue. They are so one-to-one correspondence that it is impossible to have a memory block popped up from the middle of the stack, before the pop-up, the post-stack content on him has been popped up. For details, see> data structure. We will not discuss it one by one here.
2. growth direction: For the stack, the growth direction is upward, that is, the direction to the memory address increase; For the stack, the growth direction is downward, is to increase towards memory address reduction.
3. allocation method: the heap is dynamically allocated without static allocation. There are two stack allocation methods: static allocation and dynamic allocation. Static allocation is completed by the compiler, such as local variable allocation. Dynamic Allocation is implemented by the alloca function, but the stack dynamic allocation is different from the heap dynamic allocation. Its Dynamic Allocation is released by the compiler without manual implementation.
4. allocation Efficiency: the stack is the data structure provided by the machine system, and the computer will provide support for the stack at the underlying layer: allocate a dedicated register to store the stack address, the output stack of the Pressure Stack has dedicated Command Execution, which determinesHigh stack Efficiency. The heap is provided by the C/C ++ function library, and its mechanism is very complicated. For example, to allocate a piece of memory, library functions search for available space in heap memory based on certain algorithms (for specific algorithms, refer to data structures/operating systems, if there is not enough space (probably because there are too many memory fragments), it is possible to call the system function to increase the memory space of the program data segment, so that there is a chance to allocate enough memory, then return. Obviously, the heap efficiency is much lower than the stack efficiency.

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 of memory, so the meaning of this sentence is:A pointer to a heap memory is stored in the stack 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, wrong. It should beDelete [] PThis is 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;
Management Method: For stacks, it is automatically managed by the compiler without manual control. For heaps, the release work is controlled by programmers and memory leak is easily generated.
Space size: Generally, in a 32-bit system, the heap memory can reach 4 GB. From this perspective, there is almost no limit on the heap memory. But for the stack, there is usually a certain amount of space. For example, under vc6, the default stack space is 1 MB (as if so, I cannot remember ). Of course, we can modify:
Open the project and choose Project> setting> link, select output from category, and set the maximum value and commit of the stack in reserve.
Note: The minimum reserve value is 4 byte. Commit is retained in the page file of the virtual memory. Compared with the general setting, commit makes the stack open up a large value, memory overhead and startup time may be increased.
Compared with the stack, the use of a large number of new/delete operations may easily cause a large amount of memory fragments. Due to the absence of dedicated system support, the efficiency is very low; because it may lead to switching between the user State and the core state, the memory application will become more expensive. Therefore, stacks are the most widely used in applications. Even function calls are completed using stacks. The parameters and return addresses in the function call process are as follows, both EBP and local variables are stored in stacks. Therefore, we recommend that you use stacks instead of stacks.

Comparison of access efficiency:
Code:

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:

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.
Whether it is a heap or a stack, it is necessary to prevent cross-border phenomena (unless you intentionally cross-border it), because the cross-border result is either a program crash, either it is to destroy the heap and stack structure of the program and generate unexpected results. Even if the above problem does not occur during your program running, you should be careful, maybe it will collapse at some time. Writing stable and secure code is the most important thing.

For your security, please only open the URL with reliable source

Cancel website opening

From:
Http://hi.baidu.com/youngky2008/blog/item/d4b4e631221e800191ef39ca.html