在 C++ 编程里，内存泄漏是个较为常见且棘手的问题。下面为你详细介绍排查内存泄漏的方法和工具，助你在 “C++ 内存泄漏排查大赛” 中一臂之力。

一、内存泄漏的常见成因

• new 和 delete 未配对使用

void leak() {
    int* ptr = new int[10];
    // 未调用delete[] ptr;
}

•  基类析构函数未设为虚函数

class Base { /* ... */ };
class Derived : public Base { /* ... */ };
Base* ptr = new Derived();
delete ptr; // 仅调用Base的析构函数

•  智能指针使用不当

std::shared_ptr<int> ptr1(new int);
std::shared_ptr<int> ptr2 = ptr1;
ptr1.reset();
ptr2.reset();
// 此时若存在循环引用，内存仍无法释放

•  资源管理类不完善

class Resource {
public:
    Resource() { handle = acquire(); }
    ~Resource() { release(handle); } // 未考虑异常安全
private:
    Handle handle;
};

 二、内存泄漏的排查方法

1. 静态代码分析

• 工具推荐：Cppcheck、Clang-Tidy、PC-Lint
• 检查要点：
  • 查找 new 和 delete 不匹配的情况
  • 查看基类析构函数是否为虚函数
  • 检查智能指针的使用是否正确

2. 动态内存分析工具

• Valgrind（Linux）

valgrind --leak-check=full --show-leak-kinds=all ./your_program

• AddressSanitizer（ASan）

g++ -fsanitize=address -g your_file.cpp -o your_program

• Visual Studio（Windows）

#include <crtdbg.h>
#define _CRTDBG_MAP_ALLOC
int main() {
    _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
    // 你的代码
}

3. 自定义内存分配器

通过重载全局的 new 和 delete 操作符来跟踪内存分配情况：

#include <iostream>
#include <map>
#include <mutex>

std::map<void*, size_t> allocationMap;
std::mutex mtx;

void* operator new(size_t size) {
    void* ptr = std::malloc(size);
    if (ptr) {
        std::lock_guard<std::mutex> lock(mtx);
        allocationMap[ptr] = size;
    }
    return ptr;
}

void operator delete(void* ptr) noexcept {
    if (ptr) {
        std::lock_guard<std::mutex> lock(mtx);
        allocationMap.erase(ptr);
    }
    std::free(ptr);
}

// 在程序结束时检查allocationMap

4. 智能指针替换原始指针

将原始指针替换为智能指针，可有效减少内存泄漏：

// 替换前
Widget* widget = new Widget();
delete widget;

// 替换后
std::unique_ptr<Widget> widget = std::make_unique<Widget>();

5. 容器与资源管理

确保容器中的对象正确管理资源：

// 错误示例：存储原始指针可能导致泄漏
std::vector<Widget*> widgets;
widgets.push_back(new Widget()); // 需手动delete

// 正确示例：使用智能指针
std::vector<std::unique_ptr<Widget>> widgets;
widgets.push_back(std::make_unique<Widget>());

三、排查内存泄漏的步骤

1. 重现问题：找出能稳定重现内存泄漏的测试用例。
2. 使用工具检测：运用 Valgrind 或 ASan 确定泄漏位置。
3. 分析调用链：依据工具报告的调用栈，定位到泄漏的代码行。
4. 检查资源管理：确认是否存在资源获取与释放不匹配的情况。
5. 修复并验证：修改代码后，再次运行测试以确认泄漏问题是否解决。

四、预防内存泄漏的最佳实践

• 优先使用智能指针
  • std::unique_ptr：用于独占资源所有权。
  • std::shared_ptr：用于共享资源所有权。
  • std::weak_ptr：用于打破循环引用。
• 采用 RAII（资源获取即初始化）原则

class FileHandle {
public:
    explicit FileHandle(const char* filename) : file(fopen(filename, "r")) {}
    ~FileHandle() { if (file) fclose(file); }
    // 禁用拷贝构造函数和赋值运算符
    FileHandle(const FileHandle&) = delete;
    FileHandle& operator=(const FileHandle&) = delete;
private:
    FILE* file;
};

• 使用容器管理动态数组 

// 避免
int* arr = new int[100];
delete[] arr;

// 推荐
std::vector<int> arr(100);

• 使用静态代码分析工具：在 CI/CD 流程中集成 Cppcheck 或 Clang-Tidy。
• 编写单元测试：对资源管理类进行测试，确保资源能正确释放。

五、排查工具推荐

1. Valgrind：功能强大，能检测内存泄漏、越界访问等问题，但会使程序运行变慢。
2. AddressSanitizer：速度快，与 GCC/Clang 集成良好。
3. Visual Studio 内存分析器：Windows 平台下图形化的内存分析工具。
4. Google Sanitizers：包含 AddressSanitizer、MemorySanitizer 等。
5. Boost.Pool：提供内存池实现，可减少频繁分配内存带来的开销。

六、总结

排查内存泄漏需要结合多种方法和工具。在实际操作中，建议按照 “重现问题→使用工具检测→分析代码→修复验证” 的流程进行。同时，通过遵循最佳实践和使用智能指针，可以从源头上减少内存泄漏的发生。