C ++ memory allocation skills

In the C ++ programming language, memory operations are an important application skill. We have introduced three different allocation methods here, so that you can select a method suitable for your needs in actual applications, thus improving your program development efficiency.

• In-depth analysis of C ++ class template application code
• Overview of basic concepts of C ++ class template Specialization
• Understand the basic concepts of C ++ non-type template parameters
• Summary of precautions for using non-type parameters in C ++ function templates
• C ++ typename different application methods

There are three methods for C ++ memory allocation:

1) distributed from the static storage area. The program has been allocated when it is compiled, and the program exists throughout the entire runtime. For example, global variables and static variables.

2) create a stack. When a function is executed, the storage units of local variables in the function can be created on the stack. When the function is executed, these storage units are automatically released. Stack memory allocation computation is built into the processor's instruction set, which is highly efficient, but the memory capacity allocated is limited.

3) distributed from the stack, also known as dynamic memory allocation. When the program runs, it uses malloc or new to apply for any amount of memory. The programmer is responsible for releasing the memory with free or delete. The lifetime of the dynamic memory is determined by us. It is very flexible to use, but the problem is also the most.

Memory usage Error

Memory Errors are very troublesome. The compiler cannot automatically detect these errors, which can be captured only when the program is running. Most of these errors do not have obvious symptoms, but they are often invisible and increase the difficulty of error correction. Sometimes the user finds you angrily, but the program has not encountered any problems. When you leave, the error occurs again. Common memory errors and their countermeasures are as follows:

* C ++ uses the memory instead of being allocated successfully.

New programmers often make this mistake because they do not realize that memory allocation will fail. A common solution is to check whether the pointer is NULL before using the memory. If you use malloc or new to apply for memory, you should use if (p = NULL) or if (p! = NULL.

* Although the memory allocation is successful, it is referenced before initialization. There are two main causes for this mistake: first, there is no idea of initialization; second, the default memory initial values are all zero, resulting in reference initial values errors, such as arrays ). There is no uniform standard for the default initial values of the memory. Although sometimes it is zero, we prefer to trust it without any trust. Therefore, no matter which method is used to create an array, do not forget to assign the initial value. Even the zero value cannot be omitted, so do not bother.

* The C ++ memory is successfully allocated and initialized, but the operation is beyond the memory boundary. For example, when an array is used, the subscript "more than 1" or "less than 1" is often performed. Especially in for loop statements, the number of loops is easy to make a mistake, resulting in array operations out of bounds.

* Forgot to release the memory, causing memory leakage. A function containing such errors loses a piece of memory every time it is called. At the beginning, the system had sufficient memory and you could not see the error. Once a program suddenly died, the system prompts: memory is exhausted. Dynamic Memory application and release must be paired, and the usage of malloc and free in the program must be the same, otherwise there must be a new/delete error ).

* The memory is released but it is used again.

There are three scenarios:

1) The object calling relationship in the program is too complex, so it is difficult to figure out whether an object has released the memory. At this time, we should re-design the data structure to fundamentally solve the chaos of Object Management.

2) The return Statement of the function is incorrect. Be sure not to return the "Pointer" or "Reference" pointing to "stack memory" because the function body is automatically destroyed when it ends.

3) after free or delete is used to release the memory, the pointer is not set to NULL. As a result, a "wild pointer" is generated ".

Rule 1: After applying for memory with malloc or new, check whether the pointer value is NULL immediately. Prevent the use of memory with NULL pointer values

Rule 2: Do not forget to assign initial values to arrays and dynamic memory. Avoid using uninitialized memory as the right value.

Rule 3: avoid overrunning the subscript of an array or pointer. Be careful when "more than 1" or "less than 1" is performed.

Rule 4: dynamic memory application and release must be paired to prevent memory leakage.

Rule 5: After the memory is released with free or delete, the pointer is immediately set to NULL to prevent "wild pointer ".

The preceding section describes how to allocate C ++ memory.