带有向量的类构造函数中的析构函数调用

Question

我有以下类，它简单地包装了一个数组，并用构造函数向它添加了一些元素：

class myArray {
public:
    myArray();
    myArray(int a, int b);
    myArray(int a, int b, int c);
    myArray(myArray&& emplace);

    ~myArray();

    int& operator [](int id);

private:
    int *data;
};

myArray::myArray() {
    data = new int[1];
    data[0] = 0;
}

myArray::myArray(int a, int b) {
    data = new int[3];
    data[0] = 0;
    data[1] = a;
    data[2] = b;
}

myArray::myArray(int a, int b, int c) {
    data = new int[4];
    data[0] = 0;
    data[1] = a;
    data[2] = b;
    data[3] = c;
}

myArray::~myArray() {
    std::cout << "Destructor"<<std::endl;
    delete[] data;
}

int& myArray::operator [](int id) {
    return data[id];
}

myArray::myArray(myArray&& emplace) : data(std::move(emplace.data)) {}

此外，我还有第二类，其中包含第一类元素的向量 (myArray)。

class Queue {
public:
    Queue();

private:
    std::vector<myArray> _queue;
};

Queue::Queue {
    _queue.reserve(1000);
    for(int a = 0; a < 10; a++)
        for(int b = 0; b < 10; b++)
            for(int c = 0; c < 10; c++)
                        _queue.emplace_back(a,b,c);
}

我的问题是：为什么在 Queue 构造函数的末尾调用 myArray 元素的析构函数？ Queue 对象在我的主程序中仍然存在，但 myArray 的析构函数释放了分配的内存，因此我得到了分段错误。

有没有办法避免调用析构函数，或者直到队列对象生命周期结束时才调用它？

Answer 1

您的移动构造函数没有将移动对象上的 data 设置为 null，因此当移动对象被破坏时，它会尝试释放数据。

如果你有 c++14，你可以使用std::exchange 来实现这个：

myArray::myArray(myArray&& emplace)
 : data{std::exchange(emplace.data, nullptr)})
{}

否则你需要这样做：

myArray::myArray(myArray&& emplace)
 : data{emplace.data)
{
  emplace.data = nullptr;
}

移动构造函数将由std::vector 调用，因为它会在您调用emplace_back 时重新分配以增加其容量。执行类似于以下步骤：

1. 分配新内存来保存元素
2. 使用在新内存中从前一个内存中的元素放置新元素来移动构造
3. 销毁之前内存中的元素
4. 释放之前的内存