移动赋值和移动构造函数都是从函数调用中发出的

Question

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

#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 中，我测试了复制构造函数和移动语义在以下情况下的实现方式：

#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

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

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

Answer 1

没有任何优化，类似如下：

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

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

将 returned b 转换为 a 需要两个步骤。首先是赋值表达式右边的构造

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

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

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

对于你的第二个，因为你不是 return 本地，而是指向动态分配内存的指针，所以必须创建一个副本来执行 return。生成的副本将是一个右值，然后在赋值中将其移至 a.

对于您的第三个示例，由于 mx 是局部变量，因此它被视为右值。 return 的构造并没有被省略（出于某种原因），但由于它是本地的，它将在 return 的构造中被移出。由于 returned 是右值，因此接下来是移动赋值。

移动赋值和移动构造函数都是从函数调用中发出的

Both move assignment and move constructor are emitted from a function call

c++

copy-constructor

move-constructor

move-semantics

c++11