Question

我是C ++ 11的新手，发现移动语义和复制椭圆非常适合编写优雅高效的代码。不过我想问一些问题。在这里，我编写了一个模板类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（）这个临时对象创建为一个。对于第三个结果有点奇怪。但是，如果我在函数范围mx中初始化本地对象mean(int axis)，那么只有一个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() */

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

对于您的第一个示例，退出的构造被省略，您只能看到作业的输出。

对于你的第二个，因为你没有返回本地，而是指向动态分配的内存的指针，所以必须有一个副本来执行返回。生成的副本将是一个右值，然后从赋值转移到a。

对于您的第三个示例，由于mx是本地的，因此将其视为右值。回报的构建并没有被省略（出于某种原因），但由于它是一个本地的，它将从回程的构造中移开。因为返回的是rvalue，所以移动赋值如下。

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

1 个答案: