C++常见内存泄漏案例分析以及解决方案

C++ 常见内存泄漏案例分析以及解决方案

1. 分配与释放不匹配

在动态内存管理中，使用new操作符分配的内存必须通过delete操作符显式释放。若未遵循这一规则，将导致内存泄漏。例如：

int *p = new int;
p = new int; // 错误：未释放先前分配的内存
delete p; // 仅释放最后一次分配的内存

对于使用new[]分配的数组，必须使用delete[]进行释放，否则同样会导致内存泄漏：

int* ptr = new int[2];
// 使用ptr...
delete[] ptr; // 正确：使用delete[]释放数组

类似地，使用malloc分配的内存必须通过free释放，否则也会造成内存泄漏：

int *p = (int*)malloc(sizeof(int));
p = (int*)malloc(sizeof(int)); // 错误：未释放先前分配的内存
free(p); // 正确：释放内存

此外，库函数如strdup()返回的内存需要显式释放，否则也会造成内存泄漏：

char* dup_str = strdup("example");
free(dup_str); // 释放内存，避免内存泄漏

2. 嵌套指针的不完全释放

在处理嵌套指针时，必须确保释放每个层级的内存。仅释放外层内存而不释放内层指针会导致内存泄漏：

int **b = new int*[M];
for(int i = 0; i < M; i++) {b[i] = new int[N];
}
// 释放内存
for(int i = 0; i < M; i++) {delete[] b[i];
}
delete[] b;

3. 基类析构函数非虚

在多态情况下，基类的析构函数必须是虚函数，以确保通过基类指针删除派生类对象时，能够正确调用派生类的析构函数，避免内存泄漏：

class A {
public:virtual ~A() {} // 正确：虚析构函数
};class B : public A {
public:~B() {}
};

4. 使用free不触发析构

使用malloc分配的类对象不会触发析构函数，导致内存泄漏：

MyClass* obj = (MyClass*)malloc(sizeof(MyClass));
new(obj) MyClass(44);
free(obj); // 错误：不会调用析构函数

正确的做法是使用new和delete：

MyClass* obj = new MyClass(44);
delete obj; // 正确：调用析构函数

5. 更新未释放内存的指针

在更新指针指向的内存时，必须先释放旧内存，否则会造成内存泄漏：

class Student {
private:char* mName;
public:// 构造函数和析构函数...void setName(const char* name) {if (this->mName != nullptr) {delete[] this->mName;}// 分配新内存...}
};

6. 无法删除引用指向的内存地址

返回动态分配内存的引用时，无法释放内存，导致内存泄漏：

int& allocateInteger() {int* p = new int(42);return *p;
}

正确的做法是返回指针：

int* allocateInteger() {int* p = new int(42);return p;
}

7. 循环引用

对象之间的循环引用会导致内存泄漏，尤其是在使用智能指针如shared_ptr时。使用weak_ptr可以解决这个问题：

class ClassA {
public:void setInnerPtr(weak_ptr<ClassB> pB) {p = pB;}
private:weak_ptr<ClassB> p;
};class ClassB {
public:void setInnerPtr(weak_ptr<ClassA> pA) {p = pA;}
private:weak_ptr<ClassA> p;
};

8. 野指针和悬挂指针

野指针指向未知或随机地址，而悬挂指针指向已释放的内存，两者都可能导致未定义行为：

int* p1; // 野指针
int* p2 = NULL; // 非野指针
p1 = new int(10); // 非野指针
delete p1; // 悬挂指针

9. 浅拷贝产生悬挂指针

未重写拷贝构造函数和赋值运算符的类，可能导致浅拷贝，从而产生悬挂指针：

class Student {
private:char* mName;
public:// 构造函数、析构函数、拷贝构造函数和赋值运算符...
};

10. 异常安全问题

在异常处理中，如果资源未在所有退出路径上正确释放，可能导致内存泄漏：

try {int* myData = new int[100];// 可能抛出异常delete[] myData;
} catch (...) {// 异常处理
}

11. 隐式内存泄漏

隐式内存泄漏包括内存碎片、内存管理块未归还操作系统、STL内部内存管理策略等，这些都可能导致内存耗尽：

• 内存碎片：大量小内存块导致无法重新分配。
• 内存管理块：运行时库可能不归还内存给操作系统。
• STL内存管理：内存可能不会立即归还操作系统。