C++ 中传值调用导致的 Double Free 崩溃与修复

问题原理：默认的浅拷贝陷阱

C++ 中，如果用户没有显式定义拷贝构造函数，编译器会生成一个默认的默认拷贝构造函数。其作用是将源对象的每个数据成员按位拷贝到目标对象中。对于简单的数据类型（如 int、float），这是安全的；但对于指向动态分配内存的指针成员，这种“按位拷贝”仅复制了指针的地址值，而非指针所指向的内容。

这意味着两个对象中的指针将指向堆上的同一块内存区域。当其中一个对象被销毁时，它会 delete[] 该内存；当另一个对象随后被销毁时，它尝试再次 delete 同一块已被释放的内存，操作系统检测到非法操作，导致程序崩溃或产生未定义行为。

复现场景：Print 函数的传值崩溃

以下示例演示了这一常见错误。类 Text 封装了一个字符指针 str，并在构造函数中为其分配了堆内存。在 main 函数中，我们将对象 t 直接传递给 Print 函数。

#include <iostream>
using namespace std;

class Text
{
private:
    char * str;
public:
    // 构造函数：分配内存
    Text(){ 
        str = new char[20];
        memset(str, 0, 20);
    }

    void SetText(char * s){
        strcpy(this->str, s);
    }

    char * GetText() const { return str; }

    // 析构函数：释放内存
    ~Text()
    {
        cout << "~Text Destruction" << endl;
        delete [] str; // 关键点：这里会释放堆内存
        cout << "~Text Over" << endl;
    }
};

// 参数为传值 (Value)，触发默认拷贝构造
void Print(Text str) 
{
    cout << str.GetText() << endl;
}

int main()
{
    Text t;
    t.SetText("abc");
    Print(t); // 传入对象 t，发生拷贝
    return 0;
}

执行流程分析：

1. 构造阶段：main 中的 t 创建成功，str 指向一块有效内存。
2. 调用阶段：调用 Print(t) 时，参数 str 被构造。由于是传值，系统调用默认的拷贝构造函数，str 的指针地址完全复制自 t.str。此时 t 和临时对象 str 指向同一内存地址。
3. 退出 Print：函数执行完毕，临时对象 str 超出作用域，调用析构函数 delete [] str。这块内存被标记为释放。
4. 退出 main：main 函数结束，局部变量 t 超出作用域，调用析构函数。此时 t.str 仍然保存着之前的地址（虽然内存已无效）。当它再次执行 delete [] str 时，即为 Double Free（重复释放），导致运行时错误。

第1步：方案一 - 重写拷贝构造函数（深拷贝）

若要保留传值调用的写法，必须确保拷贝发生时，新对象拥有独立的内存空间。需要在类中手动实现拷贝构造函数，为新指针分配新内存并复制内容。

class Text {
private:
    char * str;
public:
    Text(){ 
        str = new char[20]; 
        memset(str, 0, 20);
    }

    // 【新增】拷贝构造函数：执行深拷贝
    Text(const Text &t)
    {
        str = new char[20];          // 分配新内存
        strcpy(str, t.GetText());    // 复制内容
    }

    void SetText(char * s){ strcpy(this->str, s); }
    char * GetText() const { return str; }

    ~Text()
    {
        delete [] str; 
    }
};

效果：现在当 Print 接收参数时，新对象分配了自己的堆内存并复制了数据。临时对象析构时释放的是属于自己的内存，不会影响原对象 t。

第2步：方案二 - 改为引用传递（推荐）

在绝大多数不需要修改对象本身逻辑的场景下，对包含资源句柄（如指针、文件描述符、网络连接）的类进行传值拷贝不仅开销大（涉及内存分配和拷贝），而且容易导致上述的生命周期混淆风险。更优雅的做法是使用 常量引用。

// 使用 const 引用，无拷贝发生，零开销且安全
void Print(const Text &str)
{
    cout << str.GetText() << endl;
}

优势说明：

• 不涉及任何堆内存分配或拷贝操作，性能更高。
• 避免了所有权歧义，函数内只读取数据而不介入对象的生命周期管理。
• 从根本上杜绝了因临时对象析构导致的意外行为。

总结

在处理带有指针成员的 C++ 类时，务必警惕默认的“浅拷贝”机制。如果需要支持赋值或传值，应遵循三/五法则（Rule of Three/Five），显式定义拷贝构造函数、拷贝赋值运算符和析构函数。或者，在设计 API 时，优先考虑使用引用来传递参数，除非你确实需要一份独立的对象副本。以上就是 C++ 传值调用导致对象双重析构问题的详细内容，更多关于 C++ 内存管理与指针安全的资料请关注本站其它相关文章！