C++双重释放内存问题

概述

在C++中，双重释放内存会导致未定义行为，通常引发程序崩溃

这是因为同一块内存被多次释放会破坏内存管理器的内部数据结构

双重释放是什么意思呢？

• 应该是在程序中，同一块内存被释放了两次。
• 比如，用new分配了一个对象，然后有两个指针指向这个对象，如果这两个指针都被用来delete，那就会导致两次释放同一内存
• 这时候，程序可能会崩溃，或者出现不可预测的行为，因为内存管理的数据结构可能被破坏

案例1

int* p = new int(5);  // 步骤1：动态分配内存，p指向该内存
int* q = p;           // 步骤2：q指向同一块内存
delete p;             // 步骤3：第一次释放内存
delete q;             // 步骤4：第二次释放同一块内存（双重释放）

逐步解释

1. 内存分配
   new int(5) 在堆上分配一个 int 类型的内存块，初始化为 5，指针 p 指向该内存
2. 指针赋值
   q = p 使得 q 也指向同一块内存。此时，p 和 q 是“别名”（两个指针共享同一地址）
3. 第一次释放（delete p）
   释放 p 指向的内存，该内存被归还给内存管理器（可能标记为“未使用”或加入空闲链表）。此时，p 和 q 成为“悬垂指针”（指向无效内存）
4. 第二次释放（delete q）
   试图释放已释放的内存。此时内存管理器可能

• 检测到重复释放，直接终止程序（如 glibc 的 double free 错误）
• 破坏内部数据结构（如空闲链表），导致后续内存操作失败
• 引发堆溢出或安全漏洞（如攻击者可能利用此行为）

如何避免双重释放？

1. 使用智能指针
   std::shared_ptr 通过引用计数自动管理内存，确保内存只释放一次

std::shared_ptr<int> p = std::make_shared<int>(5);
std::shared_ptr<int> q = p;  // 引用计数+1
// 无需手动释放，离开作用域后自动释放

2. 释放后置空指针
   手动释放后，将指针设为 nullptr，后续 delete 操作无害

delete p;
p = nullptr;  // delete nullptr 是安全的
delete q;      // q 仍指向原地址，导致双重释放！
q = nullptr;  // 需要同时置空 q

3. 明确所有权
   确保每个动态分配的内存块只有一个“所有者”指针负责释放，其他指针仅作为临时借用

案例2

假设有一个简单的自定义智能指针类 smart_ptr，其模板定义如下

template <typename T>
class smart_ptr {
public:
    // 构造函数：假设此处分配或管理资源
    smart_ptr(T* ptr = nullptr) : raw_ptr(ptr) {}

    // 禁用拷贝构造函数和拷贝赋值运算符
    smart_ptr(const smart_ptr&) = delete;
    smart_ptr& operator=(const smart_ptr&) = delete;

    // 析构函数：释放资源
    ~smart_ptr() {
        delete raw_ptr;
    }

private:
    T* raw_ptr;  // 裸指针，指向动态分配的内存
};

为什么禁用拷贝构造函数和拷贝赋值运算符？

1. 如果允许拷贝会发生什么？

smart_ptr<int> ptr1(new int(42));  // ptr1 管理一块内存
smart_ptr<int> ptr2(ptr1);         // 调用拷贝构造函数，ptr2 也指向同一块内存

此时，ptr1 和 ptr2 的 raw_ptr 成员指向同一块内存。当 ptr1 和 ptr2 离开作用域时，它们的析构函数会依次调用

~smart_ptr() { delete raw_ptr; }  // ptr1 和 ptr2 都会释放同一块内存！

这会导致同一块内存被释放两次（双重释放），从而引发未定义行为（通常是程序崩溃）

2. 如何通过禁用拷贝解决问题？
   通过将拷贝构造函数和拷贝赋值运算符标记为 = delete，编译器会禁止以下操作

smart_ptr<int> ptr2(ptr1);  // 编译错误：拷贝构造函数已被删除
smart_ptr<int> ptr3 = ptr1; // 编译错误：拷贝赋值运算符已被删除

这迫使程序员无法创建多个指向同一资源的 smart_ptr 对象，从而避免双重释放

自定义的 smart_ptr 可能是一个简单的独占所有权指针（类似 std::unique_ptr），它不具备引用计数的功能

如果允许拷贝，程序员可能无意中创建多个指向同一资源的智能指针，最终导致双重释放。通过禁用拷贝，强制要求所有权的唯一性，确保资源安全