Fundamentals of Computer Programming: Stack, heap, stack concept differentiation and theoretical knowledge

I. Preliminary knowledge-memory allocation of the program
The memory used by a program compiled by C + + is divided into the following sections
1. Stack (stack)-Automatically allocated by the compiler to release, store the function parameter value, local variable value and so on. It operates in a manner similar to the data node
The stack in the structure.
2, heap area (heap)-Generally by the programmer assigned to release, if the programmer does not release, the end of the program may be recycled by the OS. Note it with the data structure
In the heap is two different, distribution is similar to the list, hehe.
3, Global Zone (Static)-, the storage of global variables and static variables is placed in a block, the initialization of global variables and static variables in
An area, an uninitialized global variable, and an uninitialized static variable in another contiguous area. -System release after the program is finished
4, literal constant area-the constant string is put here. Released by the system after the program is finished
5. Program code area-binary code that holds the function body.
Ii. Examples of procedures
It was written by a predecessor, very detailed

Main.cpp
int 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 in the constant area, p3 on the stack.
static int c = 0; global (static) initialization zone
P1 = (char *) malloc (10);
P2 = (char *) malloc (20);
Areas that are allocated 10 and 20 bytes are in the heap area.
strcpy (P1, "123456"); 123456/0 in the constant area, the compiler might optimize it to a place with the "123456" that P3 points to.
}
Ii. theoretical knowledge of heaps and stacks
2.1 How to apply
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 himself and indicate the size of the malloc function in C
such as P1 = (char *) malloc (10);
Using the new operator in C + +
such as P2 = (char *) malloc (10);
But note that P1, p2 itself is in the stack.
2.2 Response of the system after application
Stack: As long as the remaining space of the stack is larger than the requested space, the system will provide memory for the program, otherwise it will report the exception prompt stack overflow.
Heap: First you should know that the operating system has a list of idle memory addresses, when the system receives the application of the program,

The linked list is traversed, looking for a heap node where the first space is larger than the requested space, and then deleting the node from the list of idle nodes and
Space is allocated to the program, and for most systems, the size of this allocation is recorded at the first address in the memory space, so that the code
Delete statement to properly release this memory space. Also, because the size of the found heap node does not necessarily exactly equal the size of the request, the system
Automatically re-put the extra part in the idle list.
2.3 Application Size Limits
Stack: Under Windows, the stack is the data structure to the low address extension, which is a contiguous area of memory. The address of the top of the stack and the stack's
The maximum capacity is the system pre-defined, under Windows, the size of the stack is 2M (and some say 1M, in short, is a compile-time to determine the often
If the requested space exceeds the remaining space on the stack, the overflow will be prompted. Therefore, the space available from the stack is small.
Heap: A heap is a data structure that extends to a high address, and is a discontinuous area of memory. This is because the system is stored with a linked list of free memory addresses, since
It is not contiguous, and the traversal direction of the list is from the low address to the high address. The size of the heap is limited by the valid virtual memory in the computer system. This allows
See, the heap obtained more flexible space, but also relatively large.
2.4 Comparison of application efficiency:
The stack is automatically assigned by the system and is faster. But programmers can't control it.
Heap is the memory allocated by new, the general speed is relatively slow, and prone to memory fragmentation, but the most convenient to use.
In addition, under Windows, the best way is to allocate memory with VirtualAlloc, he is not in the heap, nor is the stack directly in the process's address space
Keep a fast memory, although the most inconvenient to use. But it's fast and flexible.
2.5 Storage contents in stacks and stacks
Stack: When a function is called, the first stack is the address of the next instruction (the next executable statement of the function call statement) in the main function, and
After the parameters of the function, in most C compilers, the arguments are in the right-to-left stack, and then the local variables in the function. Note Static variables
is not into the stack. When the function call is finished, the local variable is first out of the stack, then the parameter, and the last stack pointer points to the first saved address, i.e. the main function
Next instruction, the program continues to run from that point.
Heap: The size of a heap is typically stored in a heap at the head of a pile. The concrete contents of the heap are arranged by programmers.
2.6 Comparison of access efficiency
Char s1[] = "AAAAAAAAAAAAAAA";
Char *s2 = "BBBBBBBBBBBBBBBBB";
AAAAAAAAAAA is assigned at run time;
And BBBBBBBBBBB is determined at compile time;
However, in subsequent accesses, the array on the stack is faster than the string that the pointer points to (for example, a heap).
Like what:
#include
void Main ()
{
char a = 1;
Char c[] = "1234567890";
Char *p = "1234567890";
A = c[1];
A = p[1];
Return
}
The corresponding assembly code
10:a = c[1];
00401067 8A 4D F1 mov cl,byte ptr [ebp-0fh]
0040106A 4D FC mov byte ptr [ebp-4],cl
11:a = p[1];
0040106D 8B-EC mov edx,dword ptr [ebp-14h]
00401070 8A mov al,byte ptr [edx+1]
00401073 FC mov byte ptr [ebp-4],al
The first reads the elements in the string directly into the register CL, while the second one reads the pointer value into EDX, which is read from the edx
characters, apparently slow.?
2.7 Summary:
The difference between heap and stack can be seen in the following analogy:
Use stacks like we eat in a restaurant, just order (send an application), pay, and eat (use), eat enough to go, do not bother to cut vegetables, wash
Dishes such as preparation and washing dishes, brush pots and other finishing work, his advantage is quick, but the freedom is small.
The use of the heap is like a DIY dish that you like to eat, more trouble, but more in line with their own tastes, and great freedom.
The difference between heap and stack is mainly divided into:
The operating system stack and stack, as said above, not much to say.
There are heaps and stacks of data structures that are different concepts. The heap here actually refers to the priority queue (which satisfies the heap nature)
A data structure, the 1th element has the highest priority; The stack is actually a mathematical or data structure that satisfies the advanced nature of the post.
Although stacks, stacks are said to be linked together, but they are still very different, connected to call only because of historical reasons.

Fundamentals of Computer Programming: Stack, heap, stack concept differentiation and theoretical knowledge