4

我正在尝试在其内部交换一个对象。它可以工作，但是当我添加一个析构函数时，它会给我一个双重免费错误。有没有办法防止这种情况？我说的方法是void swap(SimpleArray &object)。

（抱歉，如果您在我的帖子中有错误信息之前阅读了此内容...）

#include "TestType.h"
class SimpleArray {

    private: 
        TestType* pArray;
        //TestType* temp;
    public:
        SimpleArray(TestType *array)
        {
            this->pArray = array;
        }
        ~SimpleArray() { delete[] pArray; }
        SimpleArray() { pArray = 0;}
        SimpleArray(const SimpleArray& arg){ pArray = arg.pArray; }
        ~SimpleArray() { delete[] pArray; }
        TestType * get() const{ return pArray; }
        bool isNonNull() const { return pArray != 0; }
        //TestType* pArray;
        void reset(TestType*& p) {this->pArray = p; }
        void reset() { pArray = 0; }

        void swap(SimpleArray &object) { SimpleArray temp; temp = object; object = *this; *this = temp;}
        TestType * release() { pArray = 0; return pArray; }
        TestType& getReference(int a) { return *pArray; }


};

这可行，但是一旦我添加了析构函数，它就会给我一个“双重释放或损坏错误”。我该如何解决这个问题？这是 main 中的函数，它搞砸了。

bool testGetReleaseSwap() {
    SimpleArray array1;
    if (array1.get() != 0)
        return false;

    TestType* directArray1 = new TestType[100];
    array1.reset(directArray1);
    if (array1.get() != directArray1)
        return false;

    TestType* directArray2 = new TestType[50];
    SimpleArray array2(directArray2);

    array1.swap(array2);
    if (array1.get() != directArray2 || array2.get() != directArray1)
        return false;

    array2.swap(array1);
    if (array1.get() != directArray1 || array2.get() != directArray2)
        return false;

    array1.swap(array1);
    if (array1.get() != directArray1)
        return false;

    if (array1.release() != directArray1 || array2.release() != directArray2)
        return false;

    if (array1.get() != 0 || array2.get() != 0)
        return false;

    delete[] directArray1;
    delete[] directArray2;

    return true;
}
4

2 回答 2

6

temp.release()如果您的swap方法防止双重删除，那么这里最简单的方法是在最后调用。

不过，潜在的问题要深得多。在 C++ 中，始终保持对谁拥有某物的严格语义至关重要，例如需要删除的内存区域。

一种常见的模式是分配某物的对象也负责清理，而没有其他人负责。这很适合SimpleArray，但是复制构造函数会破坏它，因为它会乘以所有者的数量！

要实现共享数据语义，您必须投入更多工作（引用计数等），或者您必须禁止数组复制并使复制构造函数私有。

swap在不复制对象的情况下修复工作的一种干净方法是：

 void swap(SimpleArray &object) { 
    TestType* temp = object.pArray;
    object.pArray = this->pArray;
    this->pArray = temp;
 }

（std::swap(object.pArray, pArray);也可以）

因为交换数组的内存区域非常适合单所有者模式，所以这里出错的只是使用完整的对象副本。

您应该阅读 C++ 中的资源管理和所有权语义。除非您绝对知道谁拥有什么，否则您的代码总是容易出错。

于 2012-08-26T23:55:14.390 回答
2

在我看来，您正在尝试实现一个具有浅复制语义（并且可能是写时复制）的类。要成功地做到这一点，您需要跟踪有多少其他共享数据的所有者仍然存在并且需要销毁拥有的对象，当该计数达到零时。您可以使用 astd::shared_ptr或自己实现引用计数。

至于该特定示例中的真正问题，请查看复制构造函数在做什么。它不是复制，而是简单地对其参数已经拥有的对象进行另一个引用（具体的指针）。这本身就足以获得双重免费，而您的swap测试用例只是暴露了这个问题。

于 2012-08-27T00:05:24.030 回答