The difference between the heap and stack of the memory allocation of the program

Stack overview

?? In the computer world, stacks are a concept that cannot be overlooked, and stacks are two data structures. A stack is an ordered data structure of data items that can be inserted and deleted only at one end (called the top of the stack). In single-chip microcomputer applications, the stack is a special storage area, the main function is to temporarily store data and addresses, often used to protect breakpoints and the scene. Key points: Heap, queue first, last in first out (for example: Bus queue, first come in front of the car first, then the back of the row after the car). Stack, advanced After (First-in/last-out) (for example: Supermarket line checkout, Big supermarket cashier is a long narrow aisle, originally the next is you, suddenly this cashier said not knot, OK, Stack formed, row in front of to go out).

One, the memory allocation of the program 1, a program compiled by C + + is divided into the following parts of the memory 1), stack area (stack)

The compiler automatically allocates releases, stores the function's parameter values, the values of local variables, and so on. Its
Operations are similar to stacks in data structures.

2), heap area (heap)

Usually released by the programmer, if the programmer does not release, the program ends may be returned by the OS
Inbox Note that it is not the same as the heap in the data structure, but the distribution is similar to the linked list.

3), Global Zone (Static zone) (Statics)

The storage of global variables and static variables is placed in a block, initialized global variables and static variables in an area, uninitialized global variables and uninitialized static variables in another contiguous area. Released by the system after the program is finished.

4), text constant area

The constant string is placed here and released by the system at the end of the program.

5), Program code area

Binary code that holds the body of the function.

2. How to store variables

?? First, when a static variable is defined, the compiler is automatically initialized to 0 if no initialization is initialized. Next, if the variable is initialized with a constant expression, the compiler can evaluate the expression based only on the contents of the file (including the header file included), and the compiler will perform a constant expression initialization. When necessary, the compiler performs a simple calculation. If there is not enough information, the variable will be initialized dynamically. Take a look at the code:

intglobal_1= +;//static variable external link constant expression initializationintglobal_2;//static variable external link zero initializationStatic intone_file_1= +;//static variable internal link constant expression initializationStatic intone_file_2;//static variable internal link zero initializationintMain () {Static intcount_1= +;//static variable non-linked constant expression initializationStatic intcount_2;//static variable non-linked zero initializationreturn 0;}

?? All static persistent variables have the following initialization characteristics: all bits of the uninitialized static variable are set to 0. This variable is called 0 initialization. The above code illustrates the two usages of the keyword static, but with a somewhat different meaning: when used for local declarations to indicate that a variable is a static variable that is not linked, static represents storage persistence, while static represents the internal linkage when declared outside the block, and the variable is static and persistent. Some people call it the keyword overload, meaning that the keyword depends on the context.

Ii. the difference between a C + + heap and a stack 1. Different Management methods

Stacks, which are automatically managed by the compiler without manual programmer control; heap: Generation and release are controlled by the programmer.

2. Different space sizes

The stack has limited space, and heap memory can reach 4G.

3. can produce different fragments

The stack is not fragmented because the stack is an advanced post-out queue. The heap is prone to fragmentation, multiple new/delete
can cause memory discontinuities, resulting in large amounts of fragmentation.

4. Different direction of growth

The way the heap is grown is upward and the stack is downward.

5. Different distribution methods

The heap is dynamically allocated. Stacks can be statically allocated and dynamically allocated, but the dynamic allocation of stacks is freed by the compiler.

6. Different cache levels:

1), the stack uses a first-level cache, they are usually transferred in the storage space, the call is finished immediately released;
2), the heap is stored in the level two cache, the life cycle is determined by the garbage collection algorithm of the virtual machine (not once orphaned objects can be recycled). So the speed of calling these objects is relatively low.

7. Different allocation efficiency

?? The stack is the data structure provided by the machine system, and the bottom of the computer supports the stack: allocating the address of the special register storage stack, and the stack-stack has special instructions. The heap is provided by the C + + function library, the library function will follow a certain algorithm in the heap memory to search for enough space available, if there is not enough space (perhaps due to too much memory fragmentation), 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 divide enough memory, Then the return. Obviously, the heap is much less efficient than the stack.
?? Heap and Stack, due to the use of a large number of new/delete, prone to large amounts of memory fragmentation, due to lack of dedicated system support, inefficient, due to the possibility of triggering user-state and nuclear mentality of the switch, memory applications, the cost becomes more expensive. So the stack is the most widely used in the program, even if the call of the function is done by the stack, the parameters in the function call, the return address, the EBP and the local variables are all stored in a stack. So, we recommend that you try to use stacks instead of heaps.
?? Stacks are less flexible than heaps, sometimes allocating a lot of memory space, or using heaps better.
?? Whether it is a heap or stack, to prevent the occurrence of cross-border phenomenon.

Example Program

//main.cpp  intA =0; Global initialization ZoneChar*P1; Global uninitialized area main () {intb StackCharS[] ="ABC"; StackChar*P2; StackChar*P3 ="123456";123456/0In the constant area, p3 on the stack.Static   intc =0; Global (static) initialization zone P1 = (Char*)malloc(Ten); P2 = (Char*)malloc( -); Assigned toTenAnd -The area of the byte is in the heap area.strcpy(P1,"123456");123456/0In a constant area, the compiler might associate it with the P3-"123456"Optimized into one place. }

Three, Java heap and stack difference 1. Stacks and heaps (heap) are places that Java uses to store data in RAM.

Unlike C + +, Java automatically manages stacks and heaps, and programmers cannot directly set up stacks or heaps.

2. The advantage of the stack is that the access speed is faster than the heap, second only to the registers directly in the CPU.

However, the disadvantage is that the size and lifetime of the data in the stack must be deterministic and inflexible. In addition, stack data can not be shared between multiple threads or multiple stacks, but multiple variables with equal values within the stack can point to an address, see 3rd. The advantage of the heap is that the memory size can be allocated dynamically, and the lifetime does not have to tell the compiler beforehand that the Java garbage collector automatically collects the data that is no longer in use. However, the disadvantage is that the access speed is slower due to the dynamic allocation of memory at run time.

There are two kinds of data types in 3.Java.

One is the basic type (primitivetypes), a total of 8 kinds, namely Int,short, long, byte, float, double, Boolean, char (note, and no basic type of string). The definition of this type is through such as int a= 3; Long B = 255L; the form to be defined, called an automatic variable. It is worth noting that the automatic variable is a literal value, not an instance of a class, that is not a reference to a class, there is no class here. such as int a= 3; Here A is a reference to the int type, pointing to the literal value of 3. The data of these literals, due to the size of the known, the lifetime of the known (these values are fixed in a program block, the program block exits, the field value disappears), for the sake of speed, it exists in the stack.
In addition, the stack has a very important particularity, is that there is data in the stack can be shared. Let's say we define both:

int a=3;int b=3;

The compiler first processes int a= 3; First it creates a memory space in the stack with a variable of a, and then looks for an address with a literal value of 3, finds an address that holds the literal value of 3, and then points A to the address of 3. Then the INT b= 3 is processed, and after the reference variable of B is created, B is pointed directly to the address of 3 because there is already 3 of the literal value in the stack. In this case, A and B both point to 3.
It is particularly important to note that the reference to this literal is different from the reference to the class object. Assuming that a reference to two class objects points to an object at the same time, if an object reference variable modifies the internal state of the object, then another object reference variable will immediately reflect that change. Conversely, modifying its value by a reference to a literal value does not result in another case where a reference to that literal is changed. As in the example above, we define the value of a and B and then make a=4; then B will not be equal to 4 or equal to 3. Inside the compiler, when it encounters A=4, it will re-search the stack for a literal value of 4, and if not, re-open the value of the address 4, and if so, point a directly at the address. Therefore the change of a value does not affect the value of B.
The other is the wrapper class data, "such as integer,string, double, and so on the corresponding basic data type wrapper up class." These classes of data all exist in the "heap", Java with the new () statement to tell the compiler, at run time as needed to dynamically create, and therefore more flexible, but the disadvantage is to take more time. 4.String is a special packing class data. That is, it can be created in the form of string str = new String ("abc"), or in the form of STRINGSTR = "abc" (In contrast, before JDK 5.0, you have never seen an expression of integer i = 3; Because classes and literals are not generic, except for string. And in JDK5.0, this expression is possible! Because the compiler is converting the integer i = new Integer (3) in the background. The former is the process of creating a canonical class, that is, in Java, everything is an object, and the object is an instance of the class, all created in the form of new (). Some classes in Java, such as the DateFormat class, can return a newly created class through the class's getinstance () method, which seems to violate this principle. actually otherwise The class uses a singleton pattern to return an instance of the class, except that the instance is created inside the class through new (), and getinstance () hides this detail from the outside. So why is the case in string str = "abc", not created by new (), a violation of the above principle? Not really.

4. About the internal work of string str = "abc".

Inside Java, this statement is translated into the following steps: "String str =" ABC ", string str is not attached"
(1) First define an object reference variable named str to the String class: String str;
(2) "in the stack" to find the address that has the value "ABC", if not, then open a store with a literal "ABC" address, then create a new string class of Object o, and the string value of O point to the address, and in the stack next to this address note the referenced object o. If you already have an address with a value of "ABC", look for the object o and return the address of O. "" The data is stored in the heap, which says the data is stored in the stack "[because this is not created by new ()]
(3) Point Str to the address of the object o.
It is important to note that the string values in the generic string class are directly stored values. But like string str = "abc"; In this case, the string value is a reference to the data in the existing stack!
To better illustrate this problem, we can verify it by following several code.

String str1="abc";String str2="abc";System.out.println(str1==str2);//true

Note that we do not use Str1.equals (STR2) in this way, as this will compare the values of two strings for equality. = = number, as described in the JDK, returns true only if two references point to the same object. And what we're looking at here is whether str1 and str2 all point to the same object.
The result shows that the JVM created two references str1 and str2, but only one object was created, and two references pointed to the object.
Let's go further and change the above code to:

String str1="abc";String str2="abc";str1="bcd";System.out.println(str1+","+str2);//bcd,abcSystem.out.println(str1==str2);//false

This means that the change in the assignment has led to a change in the class object reference, and str1 points to another new object! And str2 still points to the original object. In the example above, when we change the value of str1 to "BCD", the JVM discovers that there is no address for that value in the stack, opens up this address and creates a new object whose string value points to the address.
In fact, the string class is designed to be immutable (immutable) classes. If you want to change its value, yes, but the JVM silently creates a new object at run time based on the new value, and then returns the address of the object to the reference of the original class. This creation process is entirely automatic, but it takes up more time. In the environment that is more sensitive to time requirements, it will have some adverse effects.
Then modify the original code:

String str1="abc";String str2="abc";str1="bcd";String str3=str1;System.out.println(str3);//bcdString str4="bcd";System.out.println(str1==str4);//true

Let's look at the following code again.

StringnewString("abc"); 　　String"abc"//falseString"abc"; 　　StringnewString("abc"//false 

Two references were created. Two objects were created. Two references point to a different two objects, respectively.
The above two code shows that as long as new () is used to create the object, it is created in the heap, and its string is stored separately, even if the data in the stack is the same, it is not shared with the data in the stack.

5. The value of the data type wrapper class cannot be modified.

Not only the value of the string class cannot be modified, but all data type wrapper classes cannot change their internal values.

6. CONCLUSIONS AND recommendations:

(1) When we use a format definition class such as String str = "ABC", we always want to think of course that we created the object str of the String class. Worry about traps! The object may not have been created! The only certainty is that a reference to the string class was created. As to whether the reference is pointing to a new object, it must be considered in terms of context, unless you create a new object with a prominent way through the new () method. Therefore, it is more accurate to say that we have created a reference variable to the object of the String class str, which refers to a variable that points to a string class with the value "ABC". Being aware of this is helpful in troubleshooting bugs that are difficult to find in a program.
(2) The use of string str = "abc", in a way that can improve the speed of the program to a certain extent, because the JVM will automatically based on the actual data in the stack to determine whether it is necessary to create a new object. For stringstr = new String ("abc"), the code creates new objects in the heap, regardless of whether their string values are equal, and it is necessary to create new objects, thereby aggravating the burden of the program. This idea should be the idea of the meta-mode, but it is not known whether the internal JDK implements this pattern.
(3) Use the Equals () method when comparing the values in the wrapper class, and use the = = when testing whether the references to the two wrapper classes point to the same object.
(4) Because of the immutable nature of the string class, you should consider using the StringBuffer class when a string variable needs to change its value frequently to improve program efficiency

Iv. theoretical knowledge of heaps and stacks 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 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 = new CHAR[10];
But note that P1, p2 itself is in the stack.

2, the 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 of all should know that the operating system has a record of the free memory address of the list, when the system receives the application of the program, it will traverse the list, look for the first space is larger than the requested space of the heap node, and then delete the node from the list of idle nodes, and the node's space allocated to the program, in addition, The size of this allocation is recorded at the first address in this memory space, so that the DELETE statement in the code can properly free up the memory space.
Also, because the size of the found heap node does not necessarily equal the size of the request, the system automatically re-places the extra portion into the idle list.

3, the application size limit

Stack: Under Windows, the stack is the data structure to the low address extension, which is a contiguous area of memory. This sentence means that the top of the stack of the address and the maximum capacity of the stack is the system pre-defined, in Windows, the size of the stack is 2M (also said 1M, in short, is a compile-time determination of the constant), if the request for more space than the stack's remaining space, will prompt overflow. 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 address, is naturally discontinuous, and the chain of the list of traversal direction is from the low address to high address. The size of the heap is limited by the valid virtual memory in the computer system. Thus, the space of the heap is more flexible and relatively large.

4, the application efficiency comparison:

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
Preserves a chunk of memory directly in the address space of the process, although it is most inconvenient to use. But the speed is fast, also the most flexible.

5. Storage content in heaps and stacks

Stack: In a function call, the first stack is the address of the next instruction in the main function (the next executable statement of the function call statement), and then the parameters of the function, in most C compilers, the arguments are left-to-right and then the local variables in the function. Note that static variables are not in 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, which is the next instruction in the main function, and 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 the programmer.

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 values into edx and then reads the characters according to EdX, which is obviously slow.

7, Summary:

The difference between heap and stack can be seen in the following analogy:
Use the stack like we go to a restaurant to eat, just order (send application), pay, and eat (use), eat enough to go, do not bother to cut vegetables, wash vegetables and other preparation work and washing dishes, brush pots and other finishing work, his advantage is fast, 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.

Copyright NOTICE: This article for Bo Master original article, without Bo Master permission not reproduced.

The difference between the heap and stack of the memory allocation of the program