c++ - 使用 copy-and-swap 惯用法，被复制对象的析构函数如何不解除分配指向内存？

我在阅读以下问题：

What is the copy-and-swap idiom?

我给人的印象是，当一个对象通过值传递时，它是指针和值被复制，但是传递的对象指针所指向的内存没有被复制。因此，当重载赋值运算符时，如链接示例中所示：

#include <algorithm> // std::copy
#include <cstddef> // std::size_t

class dumb_array
{
public:
    // (default) constructor
    dumb_array(std::size_t size = 0)
        : mSize(size),
          mArray(mSize ? new int[mSize]() : 0)
    {
    }

    // copy-constructor
    dumb_array(const dumb_array& other)
        : mSize(other.mSize),
          mArray(mSize ? new int[mSize] : 0),
    {
        // note that this is non-throwing, because of the data
        // types being used; more attention to detail with regards
        // to exceptions must be given in a more general case, however
        std::copy(other.mArray, other.mArray + mSize, mArray);
    }

    // destructor
    ~dumb_array()
    {
        delete [] mArray;
    }

    friend void swap(dumb_array& first, dumb_array& second) // nothrow
    {
        // enable ADL (not necessary in our case, but good practice)
        using std::swap;

        // by swapping the members of two classes,
        // the two classes are effectively swapped
        swap(first.mSize, second.mSize);
        swap(first.mArray, second.mArray);
    }

    dumb_array& operator=(dumb_array other) // (1)
    {
        swap(*this, other); // (2)

        return *this;
    }

private:
    std::size_t mSize;
    int* mArray;
};

...复制对象的析构函数如何不消除指向资源的mArray？现在，要在其上进行分配的对象没有复制的mArray指针指向潜在释放的内存吗？行swap(first.mArray, second.mArray);是否分配新的内存并复制前一个数组的内容？

最佳答案

当您的副本构造函数实现后，

dumb_array(const dumb_array& other)
        : mSize(other.mSize),
          mArray(mSize ? new int[mSize] : 0),

mArray中的dumb_array被深深复制。不仅复制了指针，还创建了一个全新的数组，并用std::copy()填充了内容的副本。

因此，当执行operator=(dumb_array other)时，this->mArray和other.mArray（由于参数是对象而不是引用，因此是副本）是两个不同的数组。在swap()之后，other.mArray保留最初由this->mArray保留的指针。当operator=()返回时，other.mArray可以被~dumb_array()删除。