What are the common types of C++ memory leaks?

Common types of memory leaks in C++ are: dangling pointers, resource leaks, wild pointers and memory growth. Dangling pointers refer to pointers to freed memory; resource leaks refer to allocated system resources that are not released; wild pointers refer to pointers to uninitialized memory; memory growth is due to gradual, uncontrollable memory accumulation. In practice, even simple classes can cause dangling pointer leaks if not carefully managed.

Common types of memory leaks in C++

1. Dangling Pointers

A dangling pointer refers to a pointer to memory that has been released or destroyed. This leak occurs when there are still pointers referencing the memory pointed to by the pointer after it is freed. For example:

int* ptr = new int; // 分配内存
delete ptr; // 释放内存
*ptr = 10; // 悬垂指针访问已释放的内存

2. Resource Leaks

Resource leaks occur when allocated system resources (such as files, network connections, or database connections) are no longer available When not released when needed. This renders the resources unavailable for other purposes and may eventually cause the system to crash. For example:

FILE* file = fopen("test.txt", "w"); // 打开文件
// ... 对文件进行操作 ...
fclose(file); // 文件打开后应立即关闭

3. Wild Pointers

A wild pointer refers to a pointer to uninitialized memory. It may point to any memory address, causing unpredictable behavior, including memory leaks. For example:

int* ptr; // 未经初始化的指针
*ptr = 10; // 野指针访问未定义的内存

4. Memory Bloat

Memory Bloat is a progressive leak in which memory slowly accumulates in an uncontrollable manner. It can be caused by a small leak or by not freeing a temporarily allocated memory block. For example:

for (int i = 0; i < 1000000; i++) {
  // 为每个迭代分配一个新对象
  new Object;
}

Practical case

Consider the following code:

class MyClass {
public:
  MyClass() {
    ptr = new int;
  }
  ~MyClass() {
    delete ptr;
  }
  int* ptr;
};

int main() {
  MyClass* obj = new MyClass;
  delete obj; // 内存泄漏，ptr 指向已释放的内存
  return 0;
}

In this example, after the object obj is destroyed, ptr points to memory that has been freed, causing a dangling pointer leak.

To prevent memory leaks, it is important to follow these best practices:

• Always free allocated memory.
• Automatically manage resources using the RAII (Resource Acquisition Is Initialization) paradigm.
• Use smart pointers or reference counting mechanisms to track allocated memory.

The above is the detailed content of What are the common types of C++ memory leaks?. For more information, please follow other related articles on the PHP Chinese website!