C++ 内存问题：内存泄漏与野指针

C++ 给了开发者直接操作内存的能力，但也把双刃剑交到了你手里。内存泄漏和野指针是最常见也最棘手的两个问题，它们像定时炸弹一样潜伏在代码中，随时可能导致程序崩溃或安全漏洞。这篇文章会教你识别、预防和解决这些问题。

第一章：认识内存泄漏

什么是内存泄漏

内存泄漏是指程序动态分配了内存（比如用 new 或 malloc），但在不再使用时没有释放，导致这部分内存永远无法被操作系统回收。随着程序运行时间增长，泄漏的内存会不断累积，最终耗尽系统资源。

一个最基础的内存泄漏例子：

void processData() {
    int* data = new int[100];
    // 处理数据...
    // 问题：没有 delete[] data
}

每次调用 processData()，都会泄漏 100 * sizeof(int) 字节的内存。如果这个函数被循环调用几千次，内存会迅速爆炸。

内存泄漏的常见场景

场景一：异常导致跳过释放

当 new 和 delete 之间抛出异常时，释放代码永远不会执行：

void riskyFunction() {
    int* buffer = new int[1000];
    // 假设这里抛出异常
    throw std::runtime_error("Something went wrong");
    delete[] buffer;  // 永远不会执行
}

场景二：指针赋值覆盖

如果你把一个新地址赋给一个指针，而它原本指向的内存还没释放，原内存就泄漏了：

int* ptr = new int(42);
ptr = new int(100);  // 42 这个地址丢失了，内存泄漏
delete ptr;  // 只释放了 100，42 泄漏了

场景三：函数返回局部指针

返回局部变量的指针是严重错误，函数结束后栈内存会被回收：

int* badExample() {
    int local = 999;
    return &local;  // 危险！返回野指针
}

场景四：容器管理指针

标准容器不会自动释放你存储的指针指向的堆内存：

std::vector<int*> leaked;
for (int i = 0; i < 100; i++) {
    leaked.push_back(new int(i));
}
// 所有 new 出来的内存都泄漏了

第二章：认识野指针

什么是野指针

野指针是指向一块已被释放（或从未合法分配）的内存的指针。使用野指针会导致未定义行为——可能是程序崩溃、随机错误，或者更隐蔽的安全漏洞。

int* ptr = new int(42);
delete ptr;       // 内存被释放
*ptr = 100;       // 野指针写入！危险！
int value = *ptr; // 野指针读取！危险！

野指针的常见来源

来源一：双重释放

对同一块内存调用两次 delete 会导致野指针和可能的崩溃：

int* ptr = new int(42);
delete ptr;
delete ptr;  // 未定义行为！第二次释放是危险的

来源二：指针释放后未置空

释放内存后，指针仍然保存着旧地址，这就是一个野指针：

int* ptr = new int(42);
delete ptr;
// ptr 现在是野指针，但很多代码还会继续使用它

来源三：函数返回局部指针

这同时产生野指针和内存泄漏：

int* getValue() {
    int local = 10;
    return &local;  // 返回后，local 被销毁，指针变野
}

来源四：指针运算越界

指针运算超出分配范围，访问到非法内存：

int* arr = new int[10];
int* p = arr + 20;  // 越界
*p = 666;           // 写入非法内存，危险

第三章：预防与解决方案

方案一：RAII 智能指针（推荐）

RAII（Resource Acquisition Is Initialization）是 C++ 的核心安全机制。智能指针在构造时获取资源，在析构时自动释放，完全杜绝手动管理的错误。

使用 unique_ptr 的方式：

#include <memory>

void safeFunction() {
    // 方法1：直接创建
    std::unique_ptr<int[]> buffer(new int[100]);

    // 方法2（推荐）：使用 make_unique（C++14+）
    auto buffer = std::make_unique<int[]>(100);

    // 自动释放，不需要手动 delete
}

使用 shared_ptr 的方式：

void sharedExample() {
    auto ptr = std::make_shared<MyClass>();
    // 多个指针可以共享所有权
    auto alias1 = ptr;
    auto alias2 = ptr;

    // 最后一个 shared_ptr 销毁时，自动释放内存
}

解决循环引用问题：

class Node {
public:
    std::shared_ptr<Node> partner;
    // 解决方案：其中一个指针用 weak_ptr
    std::weak_ptr<Node> observer;
};

void breakCycle() {
    auto nodeA = std::make_shared<Node>();
    auto nodeB = std::make_shared<Node>();

    nodeA->partner = nodeB;
    nodeB->partner = nodeA;  // 这里会循环引用！

    nodeA->observer = nodeB;  // 用 weak_ptr 打破循环
}

方案二：容器存储值而非指针

优先使用存储对象的容器，而不是存储指针的容器：

// 不好：存储指针，需要手动管理生命周期
std::vector<MyClass*> pointerContainer;

// 推荐：存储对象，对象随容器自动释放
std::vector<MyClass> valueContainer;

如果必须存储指针，使用智能指针容器：

std::vector<std::unique_ptr<MyClass>> smartContainer;
smartContainer.push_back(std::make_unique<MyClass>());

方案三：遵循安全指针规则

养成这些习惯能避免大多数问题：

// 规则1：释放后立即置空
int* ptr = new int(42);
delete ptr;
ptr = nullptr;  // 置空后，后续使用会立即崩溃（容易发现）

// 规则2：释放前先检查
if (ptr != nullptr) {
    delete ptr;
    ptr = nullptr;
}

// 规则3：使用断言检测野指针
assert(ptr != nullptr);  // 在使用前检查

方案四：使用作用域锁

把动态分配限制在最小作用域内：

// 推荐：资源在作用域内自动管理
{
    auto data = std::make_unique<Data>();
    data->process();
    // 作用域结束，自动释放
}

// 避免这种模式
Data* globalData = nullptr;

void initialize() {
    globalData = new Data();
    // 谁负责释放？什么时候释放？容易混乱
}

第四章：调试与检测工具

工具一：Valgrind（Linux）

Valgrind 是检测内存问题的神器，能自动发现泄漏和野指针：

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

运行后会显示：

• 泄漏的内存大小和位置
• 野指针的使用情况
• 内存分配的历史记录

工具二：AddressSanitizer（GCC/Clang）

编译器级别的内存错误检测器，开销比 Valgrind 小：

g++ -fsanitize=address -g program.cpp -o program

运行时如果有内存问题，会立即输出详细信息，包括文件名和行号。

工具三：Visual Studio 诊断（Windows）

在 Windows 上用 Visual Studio 开发时，可以使用内置的诊断工具：

1. 调试菜单 → Windows → 诊断工具
2. 内存使用跟踪功能可以监控分配和释放
3. C++运行时检测可以发现双重释放等问题

工具四：静态分析工具

在编译时就能发现潜在问题：

# Clang Static Analyzer
clang --analyze your_code.cpp

# cppcheck
cppcheck --enable=all your_code.cpp

第五章：完整示例与最佳实践

实践一：资源管理类模板

封装 RAII 模式的类，管理任意资源：

template<typename T>
class ResourceGuard {
private:
    T* resource;
public:
    explicit ResourceGuard(T* r) : resource(r) {}

    ~ResourceGuard() {
        if (resource) {
            delete resource;
        }
    }

    // 禁止拷贝
    ResourceGuard(const ResourceGuard&) = delete;
    ResourceGuard& operator=(const ResourceGuard&) = delete;

    // 允许移动
    ResourceGuard(ResourceGuard&& other) noexcept : resource(other.resource) {
        other.resource = nullptr;
    }

    T* get() { return resource; }
    T& operator*() { return *resource; }
};

// 使用方式
void process() {
    ResourceGuard<int> data(new int(42));
    *data = 100;
    // 自动释放
}

实践二：工厂函数返回智能指针

统一资源创建接口：

// 推荐：返回 unique_ptr
std::unique_ptr<Connection> createConnection(const std::string& url) {
    return std::make_unique<Connection>(url);
}

// 调用方不需要关心释放
void useConnection() {
    auto conn = createConnection("https://example.com");
    conn->sendRequest();
    // 自动释放
}

实践三：容器与资源管理

容器元素是智能指针时如何安全操作：

class ObjectManager {
    std::vector<std::unique_ptr<Object>> objects;

public:
    void addObject(std::unique_ptr<Object> obj) {
        objects.push_back(std::move(obj));
    }

    // 慎用：如果返回引用，确保调用方不存储太久
    Object* findById(int id) {
        for (auto& obj : objects) {
            if (obj->id() == id) {
                return obj.get();  // 返回原始指针
            }
        }
        return nullptr;
    }

    // 安全方式：返回智能指针的引用
    std::unique_ptr<Object>& get(int index) {
        return objects[index];
    }
};

总结：关键要点

1. 优先使用智能指针：尽量用 unique_ptr 和 shared_ptr 替代裸指针，消除手动管理的风险。

2. RAII 是银弹：资源获取即初始化，让析构函数自动释放资源。

3. 释放后置空：养成 delete 后立即 ptr = nullptr; 的习惯。

4. 容器存值不存指针：除非必要，否则用 std::vector<T> 替代 std::vector<T*>。

5. 使用工具检测：Valgrind 和 AddressSanitizer 能帮你发现隐藏的问题。

内存管理是 C++ 的核心技能。掌握这些原则和技巧，你的程序会更加稳定、安全，远离那些让人头疼的崩溃和漏洞。