C. How to prevent memory leaks

You can use the smart pointer to release the pointer automatically.

Ways to avoid memory leaks:

1. Reduce unnecessary global variables or objects with long life cycles, and garbage useless data in a timely manner.

2. Pay attention to the program logic and avoid the "endless loop" argument.

3. Avoid creating too many objects.

Memory: One of the most important parts of a computer, it is the bridge to communicate with the CPU. The running of all programs in the computer takes place in memory, so the performance of the memory has a very large impact on the computer.

Memory, also known as internal memory, is used to temporarily store computing data in the CPU and to exchange data with external memory such as hard disks.

1) Try to encapsulate the allocation and release of memory in the class and automate it;

2) Avoid memory allocation during program running; (e.g. in the form of pre-allocating memory buffers) - this is actually very important;

3) It is also a way to adopt the state array of the moving stl component instead of manually allocating the object memory;

Use the so-called application-as-you-initialization method (the name may be wrong).

This is explained in C++Primer.

But how to say it. It's still up to you to be careful. Be careful of the millennium ship.

I don't know about others, but here's how I do it:

1.Try not to manually allocate memory. For example, I don't usually use arrays, but STL vectors

2.If you need to manually allocate arrays, try to use the allocation method in STL, or use the smart pointers in STL and BOOST.

3.Some applications, such as MSXML, use smart pointers whenever possible.

4.Wherever new and delete are used, first pay attention to the initialization of the pointer, then pay attention to the pairing of new and delete, and then pay attention to the wrong snapping. Many times, memory leaks are not caused by the pairing of new and delete, but by the fact that the program breaks without the memory manually allocated by the delete in a possible outcome that they did not take into account.

5.It seems that there is a specific way to detect memory leaks. But I've only heard of it, I haven't used it.

new and delete to pair up to exist... This is important.

From the user's point of view, a memory leak by itself is not harmful. As an average user, you don't feel the existence of a memory leak at all. What is really harmful is the accumulation of memory leaks, which eventually consume all of the system's memory.

From this perspective, a one-time memory leak is not harmful because it does not pile up. Implicit memory leaks, on the other hand, are very harmful because they are more difficult to detect than frequent and occasional memory leaks. In addition to taking up more memory, programs with memory leak problems can dramatically degrade the program's performance.

For servers, if this happens, even if the system doesn't crash, it can seriously affect usage.

However, there is another point, if your program memory leak happens to be written to the memory used by the system or the memory address used by other programs, then it will cause a system exception or a program crash.

If the program executes in a loop, then the new memory space will be encroached upon, and the old memory will not be released until the memory is full, making the program unable to run.

When you run the program, you run out of memory and it crashes.

Memory leaks may be caused by singletons, non-static internal classes creating static instances, handles, etc., and its solutions are as follows:

1. Causes of memory leaks

1. Memory leak caused by singleton

Since the static nature of a singleton makes its lifespan as long as the lifetime of an application, if an object is no longer needed, and the singleton object still holds a reference to the object, it will make the object unhealthy, resulting in a memory leak.

2. Memory leak caused by non-static internal classes creating static instances

For example, in an activity that starts frequently, in order to avoid creating the same data resource repeatedly, the following may appear:

3. Memory leak caused by handler

Example: Create a static object with an anonymous inner class.

2. Solutions to memory leaks

1. Minimize the use of static variables, or assign the value to null when it is finished.

2. Clarify the effective scope of memory objects, minimize the scope of objects, and do not use member variables that can be handled with local variables, because local variables will automatically pop up the stack.

3. Reduce the number of objects with a long life cycle and a short life cycle.

4. Use StringBuilder and StringBuffer to join strings, sting, StringBuilder and StringBuffer can represent strings, where string strings represent immutable strings, and the latter two represent mutable strings. If you use multiple string objects for string concatenation, you may generate a large number of temporary strings at runtime, which will be stored in memory and cause the performance of the program to be degraded.

5. Manually set the null value for the objects that do not need to be used, no matter when the GC will start to clean up, we should mark the useless objects as objects that can be cleaned up in time.

6. For various connection (database connection, network connection, IO connection) operation, be sure to display the call close closed.