c++ - move 赋值和 move 构造函数都是从函数调用中发出的

Question

我是 C++11 的新手，发现 move 语义和复制省略非常适合编写优雅高效的代码。不过我有一些问题想请教。这里我写了一个模板类 matrix.hpp 并用它来测试 move 语义的行为。

#include <vector>
#include <iostream>
using namespace std;

template<class T> class matrix {
public:
    matrix(); // default constructor
    matrix(const matrix<T>& mx); // copy constructor
    matrix(matrix<T>&& mx); // move constructor
    matrix(int rows_, int cols_);

    matrix<T>& operator= (matrix<T>&& mx); // move assignment
    matrix<T>& operator= (const matrix<T>& mx); // copy constructor

   matrix<T> mean(int axis) const;
private:
    int rows, cols;
    std::vector<T> data;
};
template<class T> matrix<T>::matrix(): rows(0), cols(0), data(0) {}
template<class T> matrix<T>::matrix (int rows_, int cols_)
    : rows(rows_), cols(cols_), data(rows * cols) {}
template<class T> matrix<T>::matrix(const matrix<T>& mx) {
    cout << "copy-tor" << endl;
    rows = mx.rows;
    cols = mx.cols;
    data = mx.data;
}
template<class T> matrix<T>::matrix(matrix<T>&& mx) {
    cout << "move-tor" << endl;
    rows = mx.rows;
    cols = mx.cols;
    data = std::move(mx.data);
}
template<class T> matrix<T>& matrix<T>::operator= (const matrix<T>& mx) {
    cout << "copy-assign" << endl;
    if (this != &mx) {
        data.clear();
        cols = mx.cols;
        rows = mx.rows;
        data = mx.data;
    }
    return *this;
}
template<class T> matrix<T>& matrix<T>::operator= (matrix<T>&& mx) {
    cout << "move-assign" << endl;
    if (this != &mx) {
        data.clear();
        rows = mx.rows;
        cols = mx.cols;
        data = std::move(mx.data);
    }
    return *this;
}
template<class T> matrix<T> matrix<T>::mean(int axis) const {
    if (axis == 1) {
      matrix<T> mx(1, cols);
      // HERE compute mean vector ...
      return mx;
    } else if (axis == 0) {
      matrix<T> mx(rows, 1);
      // HERE compute mean vector ...
      return mx;
    }
}

在 test.cpp 中，我测试了复制构造函数和 move 语义在以下情况下的实现方式:

#include "matrix.hpp"
matrix<float> f() {
    matrix<float> a(1,2);
    return a;
}
matrix<float> g() {
    matrix<float> *b = new matrix<float>(1,2);
    return *b;
}
int main() {
    matrix<float> a;
    a = f(); // (*)
    cout << "--" << endl;
    a = g(); // (**)
    cout << "--" << endl;
    a = a.mean(1);  // (***)
}

结果是:

move-assign
--
copy-tor
move-assign
--
move-tor
move-assign

第一个结果直接从 move 分配的定义中推断出来。我对第二个结果的猜测是编译器会创建对象*b的一个临时对象，然后std::move()这个临时对象到a。对于第三个结果有点奇怪。但是，如果我在函数的作用域 mean(int axis) 中初始化本地对象 mx，那么只有一个 move-assign。谁能给我解释一下？谢谢!

编辑 我刚刚编辑了 mean(int axis) 就像它在我的代码中一样。

Answer 1

没有任何优化，类似以下内容:

T fun() { T b; return b; }

int main() {
  T a;
  a = fun();
}

将返回的b变成a有两步。首先是赋值表达式右边的构造

a = /* object move constructed with value returned by fun() */

然后实际的分配发生。由于 = 的右侧是右值，因此赋值通过 move 进行。

对于您的第一个示例，省略了返回的构造，您只能看到赋值的输出。

对于第二个，由于您返回的不是本地内存，而是指向动态分配内存的指针，因此必须创建一个拷贝来执行返回。生成的拷贝将是一个右值，然后在赋值中将其从 move 到 a。

对于您的第三个示例，由于 mx 是本地的，因此它被视为右值。返回的构造没有被省略(出于某种原因)，但由于它是本地的，它将在返回的构造中被 move 。由于返回的是右值，因此接下来是 move 赋值。