Hey there! Let's break down this problem clearly:

错误是否由析构函数直接导致？ #

不一定，但它是问题爆发的最后一环。这个错误的核心原因几乎都是多个对象共享了同一块堆内存，导致析构时重复释放——而这通常是因为你没有按照作业要求实现深拷贝的拷贝构造函数和赋值运算符，用了编译器生成的默认浅拷贝版本。

举个简单场景：

• 你创建了对象a，它的data指向一块堆内存
• 用默认拷贝构造创建了b = a，此时b.data和a.data指向同一块内存
• 当a生命周期结束，析构函数释放了data的内存
• 随后b生命周期结束，析构函数再次尝试释放已经被释放的内存，就触发了double free错误

如果你的析构函数是正确的（比如写了delete[] data;），那它本身没有问题，问题出在拷贝/赋值时没有做深拷贝，让多个对象共享了内存资源。

对应的解决方法 #

按照你的作业要求，必须实现深拷贝的拷贝构造函数和赋值运算符，同时确保析构函数正确释放资源：

1. 正确实现深拷贝的拷贝构造函数 #

IntCollection::IntCollection(const IntCollection& other) {
    // 复制size和capacity
    size = other.size;
    capacity = other.capacity;
    // 分配独立的内存块
    data = new int[capacity];
    // 逐元素拷贝data数组的内容
    for (int i = 0; i < size; ++i) {
        data[i] = other.data[i];
    }
}

2. 正确实现深拷贝的赋值运算符 #

这里推荐两种方式，第一种是基础版，第二种是更安全的拷贝交换 idiom：

基础版（带自我赋值检查）

IntCollection& IntCollection::operator=(const IntCollection& other) {
    // 先检查是否是自我赋值，避免不必要的操作和错误
    if (this == &other) {
        return *this;
    }
    // 释放当前对象已有的内存
    delete[] data;
    // 复制size和capacity
    size = other.size;
    capacity = other.capacity;
    // 分配新内存并拷贝元素
    data = new int[capacity];
    for (int i = 0; i < size; ++i) {
        data[i] = other.data[i];
    }
    // 返回自身引用，支持链式赋值（比如a = b = c）
    return *this;
}

拷贝交换 idiom（更简洁安全）

// 先实现一个swap成员函数
void IntCollection::swap(IntCollection& other) {
    std::swap(size, other.size);
    std::swap(capacity, other.capacity);
    std::swap(data, other.data);
}

// 赋值运算符利用拷贝构造和swap实现
IntCollection& IntCollection::operator=(IntCollection other) {
    swap(other);
    return *this;
}

这种方式自动处理了自我赋值，而且异常安全性更好。

3. 确保析构函数正确释放内存 #

析构函数只需要负责释放data指向的数组内存，注意用delete[]而不是delete（因为是动态分配的数组）：

IntCollection::~IntCollection() {
    delete[] data;
    // 可选：将data置为nullptr，避免野指针（虽然析构后对象就销毁了，但好习惯）
    data = nullptr;
}

额外注意点 #

• 永远记住Rule of Three：如果你的类需要自定义析构函数，那么几乎肯定需要自定义拷贝构造函数和赋值运算符（C++11后还有Rule of Five，加上移动构造和移动赋值）
• 测试时可以刻意创建拷贝对象、链式赋值，验证是否还会出现double free错误

内容的提问来源于stack exchange，提问作者andreaq