如何将动态分配的数据从一个对象移动到另一个对象？

Question

我有一个使用 RAII 编写的 Array 类（为了本示例的目的而进行了超级简化）：

struct Array
{
    Array(int size) {
        m_size = size;
        m_data = new int[m_size];
    }

    ~Array() {
        delete[] m_data;
    }

    int* m_data = nullptr;
    int  m_size = 0;
};

然后我有一个函数，它引用一个数组并对其进行一些操作。我使用一个临时数组temp 来执行处理，因为有几个原因我不能直接使用引用。完成后，我想将数据从临时数组传输到真实数组：

void function(Array& array)
{
    Array temp(array.m_size * 2);

    // do heavy processing on `temp`...

    array.m_size = temp.m_size;
    array.m_data = temp.m_data;
}

明显的问题是temp 在函数末尾超出范围：触发了它的析构函数，进而删除了内存。这样array 将包含不存在的数据。

那么，将数据所有权从一个对象“移动”到另一个对象的最佳方式是什么？

Answer 1

您想要的是移动构造或移动数组类的分配，这样可以节省冗余副本。此外，它将帮助您使用std::unique_ptr，它将为您处理分配内存的移动语义，这样您就不需要自己直接进行任何内存分配。您仍然需要挽起袖子并遵循"rule of zero/three/five"，在我们的例子中是五法则（复制和移动构造函数、复制和移动赋值运算符、析构函数）。

那么，试试吧：

class Array {
public:
    Array(size_t size) : m_size(size) {
        m_data = std::make_unique<int[]>(size);
    }

    Array(const Array& other) : Array(other.size) {
        std::copy_n(other.m_data.get(), other.m_size, m_data.get());
    }

    Array(Array&& other) : m_data(nullptr) {
        *this = other;
    } 

    Array& operator=(Array&& other) {
        std::swap(m_data, other.m_data);
        std::swap(m_size,other.m_size);
        return *this;
    }

    Array& operator=(const Array& other) {
        m_data = std::make_unique<int[]>(other.m_size);
        std::copy_n(other.m_data.get(), other.m_size, m_data.get());
        return *this;
    }

    ~Array() = default;

    std::unique_ptr<int[]>  m_data;
    size_t                  m_size;
};

（实际上，将m_size 和m_data 公开是一个坏主意，因为它们是捆绑在一起的，您不希望人们与它们混淆。我还将在元素类型上对该类进行模板化，即T 代替 int 并使用 Array<int>)

现在您可以以非常直接的方式实现您的功能：

void function(Array& array)
{
    Array temp { array }; // this uses the copy constructor

    // do heavy processing on `temp`...

    std::swap(array, temp); // a regular assignment would copy
}

Answer 2

如果您坚持使用示例格式，那么您会遗漏一些东西。您需要确保临时数组不会破坏非临时数组重用的内存。

 ~Array() {
    if (md_data != nullptr) 
         delete [] m_data;
 }

并且函数需要做干净的移动

void function(Array& array)
{
    Array temp(array.m_size * 2);

    // do heavy processing on `temp`...

    array.m_size = temp.m_size;
    array.m_data = temp.m_data;
    temp.m_data = nullptr;
    temp.m_size = 0;
}

为了让它更像 c++，你可以做很多事情。即在数组中，您可以创建成员函数以从其他数组（或构造函数，或分配运算符，...）中移动数据

  void Array::move(Array &temp) {
      m_size = temp.m_size;
      temp.m_size = 0;
      m_data = temp.m_data;
      temp.m_data = 0;
  }

在 c++11 及更高版本中，您可以创建移动构造函数并从函数中返回您的值：

 Array(Array &&temp) {
      do your move here
 }
 Array function() {
      Array temp(...);
      return temp;
 }

还有其他方法。