在 C++ 中使用二维数组移动语义

Question

有人可以向我解释如何以正确的方式使用二维浮点数组进行移动语义吗？我尝试过类似的事情：

struct Matrix {
    Matrix& operator=(Matrix&& rhs) noexcept {
        if (this == &rhs) {
            return *this;
        }

        for (size_t i = 0; i < rows; ++i) {
            delete[] matrix[i];
        }

        delete[] matrix;
        matrix = rhs.matrix;

        for (size_t i = 0; i < rows; ++i) {
            matrix[i] = rhs.matrix[i];
            rhs.matrix[i] = nullptr;
        }

        rhs.matrix = nullptr;
        return *this;
    }

    ~Matrix() {
        for (size_t i = 0; i < rows; ++i) {
            delete[] matrix[i];
        }

        delete[] matrix;
    }

    int rows;
    int cols;
    float** matrix;
};

但是在一行中

rhs.matrix = nullptr

矩阵变成了nullptr，我不知道如何修复它。

我尝试只更改内部数组中的指针，但外部指针没有任何更改。但我认为这是错误的方式，因为程序逻辑变得不正确。

Answer 1

我认为最好的方法就是什么也不做。

• 您不需要创建结构来回复堆。
• 您可以选择结构数据的存储位置。
• 我仍然不确定“移动语义”的含义，但我认为是指将

  value

  从

  address target

  复制到

  address destination

  ，然后从

  address target

  释放所有者。所以当你移动指针变量时

  Move semantic

  是非常简单的操作，因为指针变量的

  value

  是指向你的数据的地址。

#include <vector>
#include <memory>
#include <iostream>
#include <iomanip>

template <typename T>
struct Matrix {

    using self_type = Matrix<T>;

    explicit Matrix(size_t in_w, size_t in_h) :
        w{ in_w },
        h{ in_h },
        content(in_w * in_h)
    {
    }
    Matrix(self_type&&) = delete;// disable move construct
    self_type& operator=(self_type&&) = delete; // disable move assignment
    
    T& operator()(size_t x, size_t y) const {
        return content[y * w + x];
    }

    const size_t w;
    const size_t h;
    mutable std::vector<T> content;//pointer to heap
};

template <typename T>
void fill_mat(const Matrix<T>& m){
    for(size_t j = 0; j < m.h; j++){
        for(size_t i = 0; i < m.w; i++){
            m(i, j) = j * m.w + i;
        }
    }
}

template <typename T>
void print_mat(const Matrix<T>& m){
    for(size_t j = 0; j < m.h; j++){
        for(size_t i = 0; i < m.w; i++){
            std::cout << std::setw(2) << m(i, j) << " ";
        }
        std::cout << "\n";
    }
}

int main(){
   auto m = std::make_unique<Matrix<int>>(2, 3); // allocate on heap
   fill_mat(*m);
   auto n = std::move(m);//no error because I didn't move data
   print_mat(*n);
}