C++内存泄漏详细说明与解决方案

原创于 2025-11-17 23:50:46 发布 · 548 阅读

7 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #开发语言

C++疑难杂症专栏收录该内容

75 篇文章

订阅专栏

C++内存泄漏详细说明与解决方案

什么是内存泄漏

内存泄漏指程序在动态分配内存后，无法释放已不再使用的内存。随着时间的推移，泄漏的内存不断累积，最终导致程序内存耗尽、性能下降甚至崩溃。

内存泄漏的类型和示例

1. 直接内存泄漏

// 最简单的内存泄漏
void directMemoryLeak() {
    int* ptr = new int(100);
    // 忘记调用 delete ptr;
    // 程序退出后，100字节内存永远丢失
}

2. 异常导致的内存泄漏

void exceptionMemoryLeak() {
    int* ptr = new int(100);
    
    someFunctionThatMayThrow();  // 如果抛出异常
    
    delete ptr;  // 这行不会执行，内存泄漏
}

// 解决方案：使用RAII
void exceptionSafe() {
    std::unique_ptr<int> ptr = std::make_unique<int>(100);
    someFunctionThatMayThrow();  // 即使抛出异常，内存也会自动释放
}

3. 容器中的内存泄漏

void containerMemoryLeak() {
    std::vector<int*> vec;
    
    for (int i = 0; i < 10; ++i) {
        vec.push_back(new int(i));  // 动态分配
    }
    
    // 错误：只清空了vector，但没有删除指针指向的内存
    vec.clear();
    
    // 正确做法：
    for (auto ptr : vec) {
        delete ptr;
    }
    vec.clear();
}

4. 循环引用导致的内存泄漏

#include <memory>

class Node {
public:
    std::shared_ptr<Node> next;
    std::shared_ptr<Node> prev;
    int data;
    
    Node(int val) : data(val) {}
};

void circularReferenceLeak() {
    auto node1 = std::make_shared<Node>(1);
    auto node2 = std::make_shared<Node>(2);
    
    node1->next = node2;  // node2 引用计数 = 2
    node2->prev = node1;  // node1 引用计数 = 2
    
    // 离开作用域时：
    // node2 引用计数 = 2 - 1 = 1 (因为node1->next还引用着)
    // node1 引用计数 = 2 - 1 = 1 (因为node2->prev还引用着)
    // 两者都无法释放，内存泄漏！
}

5. 数组内存泄漏

void arrayMemoryLeak() {
    // 分配数组
    int* arr = new int[1000];
    
    // 错误：使用delete而不是delete[]
    delete arr;  // 未定义行为，可能只释放了第一个元素
    
    // 正确：
    // delete[] arr;
}

6. 文件/资源泄漏

void resourceLeak() {
    FILE* file = fopen("data.txt", "r");
    if (file) {
        // 处理文件...
        // 忘记 fclose(file);  // 文件句柄泄漏
    }
}

检测内存泄漏的工具

1. Valgrind (Linux/Mac)

# 编译时包含调试信息
g++ -g -o program program.cpp

# 使用Valgrind检测
valgrind --leak-check=full --show-leak-kinds=all ./program

输出示例：

==12345== 40 bytes in 1 blocks are definitely lost in loss record 1 of 1
==12345==    at 0x4C2AB80: malloc (vg_replace_malloc.c:299)
==12345==    by 0x400537: directMemoryLeak() (program.cpp:5)

2. AddressSanitizer (现代编译器)

// 编译时启用AddressSanitizer
// g++ -fsanitize=address -g program.cpp -o program

#include <iostream>
#include <memory>

void leakExample() {
    int* leak = new int(42);
    // 忘记delete
}

int main() {
    leakExample();
    return 0;
}

编译运行后会显示泄漏信息。

3. Visual Studio 诊断工具 (Windows)

使用VS内置的内存诊断工具
调试时选择"诊断工具"窗口
启用"内存使用量"跟踪

解决方案和最佳实践

1. 使用智能指针（最重要！）

#include <memory>

void smartPointerSolutions() {
    // 1. unique_ptr - 独占所有权
    auto unique = std::make_unique<int>(42);
    
    // 2. shared_ptr - 共享所有权
    auto shared = std::make_shared<int>(42);
    
    // 3. weak_ptr - 打破循环引用
    std::weak_ptr<int> weak = shared;
}

2. 打破循环引用

class SafeNode {
public:
    std::shared_ptr<SafeNode> next;
    std::weak_ptr<SafeNode> prev;  // 使用weak_ptr打破循环
    int data;
    
    SafeNode(int val) : data(val) {}
};

void noCircularLeak() {
    auto node1 = std::make_shared<SafeNode>(1);
    auto node2 = std::make_shared<SafeNode>(2);
    
    node1->next = node2;
    node2->prev = node1;  // weak_ptr不增加引用计数
    
    // 可以正常释放
}

3. RAII (Resource Acquisition Is Initialization)

class FileHandler {
private:
    FILE* file_;
    
public:
    explicit FileHandler(const char* filename, const char* mode) 
        : file_(fopen(filename, mode)) {
        if (!file_) {
            throw std::runtime_error("Failed to open file");
        }
    }
    
    ~FileHandler() {
        if (file_) {
            fclose(file_);
        }
    }
    
    // 禁止拷贝
    FileHandler(const FileHandler&) = delete;
    FileHandler& operator=(const FileHandler&) = delete;
    
    // 允许移动
    FileHandler(FileHandler&& other) noexcept : file_(other.file_) {
        other.file_ = nullptr;
    }
    
    FileHandler& operator=(FileHandler&& other) noexcept {
        if (this != &other) {
            if (file_) fclose(file_);
            file_ = other.file_;
            other.file_ = nullptr;
        }
        return *this;
    }
    
    void write(const std::string& data) {
        if (file_) {
            fwrite(data.c_str(), 1, data.size(), file_);
        }
    }
};

void safeFileOperation() {
    FileHandler file("data.txt", "w");
    file.write("Hello, World!");
    // 自动关闭文件，无泄漏
}

4. 使用标准库容器

void standardContainerSolution() {
    // 使用vector代替动态数组
    std::vector<int> data(1000);  // 自动管理内存
    
    // 使用string代替char*
    std::string str = "Hello";  // 自动管理内存
    
    // 使用map/std::unordered_map
    std::map<int, std::string> mapping;
    mapping[1] = "one";  // 自动管理内存
}

5. 自定义删除器

void customDeleterExample() {
    // 对于需要特殊清理的资源
    auto fileDeleter = [](FILE* f) { 
        if (f) fclose(f); 
    };
    
    std::unique_ptr<FILE, decltype(fileDeleter)> 
        file(fopen("data.txt", "r"), fileDeleter);
}

6. 异常安全的代码

class DatabaseConnection {
    std::unique_ptr<Connection> conn_;
    
public:
    void safeOperation() {
        auto transaction = beginTransaction();  // RAII
        
        try {
            // 可能抛出异常的操作
            performDatabaseOperation();
            transaction.commit();  // 成功时提交
        }
        catch (...) {
            // 异常时自动回滚（transaction析构）
            throw;
        }
    }
};

实际工程中的预防措施

1. 代码规范

// 良好的编码习惯
class MemorySafeClass {
private:
    std::unique_ptr<Resource> resource_;  // 使用智能指针
    std::vector<Data> data_;              // 使用标准容器
    
public:
    MemorySafeClass() 
        : resource_(std::make_unique<Resource>())
        , data_(100) {  // 在构造函数中初始化所有成员
    }
    
    // 遵循Rule of Five/Zero
    ~MemorySafeClass() = default;
    MemorySafeClass(const MemorySafeClass&) = delete;
    MemorySafeClass& operator=(const MemorySafeClass&) = delete;
    MemorySafeClass(MemorySafeClass&&) = default;
    MemorySafeClass& operator=(MemorySafeClass&&) = default;
};

2. 使用现代C++特性

void modernCppFeatures() {
    // 1. auto 避免类型错误
    auto ptr = std::make_unique<int>(42);
    
    // 2. range-based for loop
    std::vector<int> vec = {1, 2, 3};
    for (const auto& item : vec) {  // 安全遍历
        std::cout << item << std::endl;
    }
    
    // 3. lambda表达式
    auto processor = [data = std::make_unique<Data>()]() {
        return data->process();
    };
}

3. 单元测试和代码审查

// 使用Google Test进行内存测试
TEST(MemoryTest, NoLeakInCriticalFunction) {
    // 测试前记录内存状态
    size_t initial_memory = getCurrentMemoryUsage();
    
    criticalFunctionThatShouldNotLeak();
    
    // 测试后检查内存
    size_t final_memory = getCurrentMemoryUsage();
    EXPECT_EQ(initial_memory, final_memory);
}

调试技巧

1. 重载new/delete进行跟踪

#include <iostream>

// 全局new/delete重载用于调试
void* operator new(size_t size) {
    void* ptr = malloc(size);
    std::cout << "Allocated " << size << " bytes at " << ptr << std::endl;
    return ptr;
}

void operator delete(void* ptr) noexcept {
    std::cout << "Freed memory at " << ptr << std::endl;
    free(ptr);
}

void operator delete(void* ptr, size_t size) noexcept {
    std::cout << "Freed " << size << " bytes at " << ptr << std::endl;
    free(ptr);
}

2. 使用自定义内存跟踪器

class MemoryTracker {
private:
    static std::atomic<size_t> allocated_;
    static std::atomic<size_t> deallocated_;
    
public:
    static void* allocate(size_t size) {
        allocated_ += size;
        return malloc(size);
    }
    
    static void deallocate(void* ptr, size_t size) {
        deallocated_ += size;
        free(ptr);
    }
    
    static void report() {
        std::cout << "Memory leak: " 
                  << (allocated_ - deallocated_) 
                  << " bytes" << std::endl;
    }
};