11

我试图理解移动语义和复制/移动省略。

我想要一个包含一些数据的类。我想在构造函数中传递数据并且我想拥有这些数据。

读完这个、这个和这个之后，我的印象是，在 C++11 中，如果我想存储一个副本，那么按值传递应该至少与任何其他选项一样有效（除了增加代码大小的小问题）。

然后，如果调用代码想避免复制，它可以通过传递一个右值而不是一个左值。（例如使用 std::move）

所以我试了一下：

#include <iostream>

struct Data {
  Data()                 { std::cout << "  constructor\n";}
  Data(const Data& data) { std::cout << "  copy constructor\n";} 
  Data(Data&& data)      { std::cout << "  move constructor\n";}
};

struct DataWrapperWithMove {
  Data data_;
  DataWrapperWithMove(Data&& data) : data_(std::move(data)) { }
};

struct DataWrapperByValue {
  Data data_;
  DataWrapperByValue(Data data) : data_(std::move(data)) { }
};

Data
function_returning_data() {
  Data d;
  return d;
}

int main() {
  std::cout << "1. DataWrapperWithMove:\n"; 
  Data d1;
  DataWrapperWithMove a1(std::move(d1));

  std::cout << "2. DataWrapperByValue:\n";  
  Data d2;
  DataWrapperByValue a2(std::move(d2));

  std::cout << "3. RVO:\n";
  DataWrapperByValue a3(function_returning_data());
}

输出：

1. DataWrapperWithMove:
  constructor
  move constructor
2. DataWrapperByValue:
  constructor
  move constructor
  move constructor
3. RVO:
  constructor
  move constructor

我很高兴在这些情况下都没有调用复制构造函数，但为什么在第二种情况下调用了额外的移动构造函数？我想任何像样的移动构造函数Data都应该很快，但它仍然让我感到烦恼。我很想使用 pass-by-rvalue-reference （第一个选项），因为这似乎会导致更少的 move 构造函数调用，但如果可以的话，我想采用 pass-by-value 和复制省略。

4

3 回答 3

4

DataWrapperByValue::data_从DataWrapperByValue::DataWrapperByValue(Data data)s 移入的争论data 从 移入d2。

对于您获得左值的情况，您得出的通过右值引用以及按值版本的结论会产生最佳性能。然而，这被广泛认为是过早的优化。Howard Hinnant（在 C++11 中编写持有 STL 容器的类的构造函数的最佳方式）和 Sean Parent（http://channel9.msdn.com/Events/GoingNative/2013/Inheritance-Is-The-Base-邪恶等级) 都指出他们考虑过这种过早的优化。原因是移动应该非常便宜，并且在这种情况下避免它们会导致代码重复，特别是如果您有多个参数可以是 r 值或 l 值。如果通过分析或测试您发现这确实会降低性能，您总是可以在事后轻松添加 pass-by-rvalue-reference。

在您确实需要额外性能的情况下，一个有用的模式是：

struct DataWrapperByMoveOrCopy {
  Data data_;
  template<typename T, 
    typename = typename std::enable_if<    //SFINAE check to make sure of correct type
        std::is_same<typename std::decay<T>::type, Data>::value
    >::type
  >
  DataWrapperByMoveOrCopy(T&& data) : data_{ std::forward<T>(data) } { }
};

在这里，构造函数总是做正确的事情，如我的现场示例所示：http: //ideone.com/UsltRA

这个可争论的复杂代码的优势可能与单个争论无关，但想象一下，如果您的构造函数有 4 个可能是 r 值或 l 值的争论，这比编写 16 个不同的构造函数要好得多。

struct CompositeWrapperByMoveOrCopy {
  Data data_;
  Foo foo_;
  Bar bar_;
  Baz baz_;
  template<typename T, typename U, typename V, typename W, 
    typename = typename std::enable_if<
        std::is_same<typename std::decay<T>::type, Data>::value &&
        std::is_same<typename std::decay<U>::type, Foo>::value &&
        std::is_same<typename std::decay<V>::type, Bar>::value &&
        std::is_same<typename std::decay<W>::type, Baz>::value
    >::type
  >
  CompositeWrapperByMoveOrCopy(T&& data, U&& foo, V&& bar, W&& baz) : 
  data_{ std::forward<T>(data) },
  foo_{ std::forward<U>(foo) },
  bar_{ std::forward<V>(bar) },
  baz_{ std::forward<W>(baz) } { }
};

请注意，您可以省略 SFINAE 检查，但这会出现一些微妙的问题，例如使用显式构造函数进行隐式转换。同样不检查参数类型的转换被推迟到构造函数内部，其中有不同的访问权限、不同的 ADL 等。请参阅实时示例：http: //ideone.com/yb4e3Z

于 2014-03-15T16:50:46.533 回答
3

DataWrapperByValue有这个构造函数：

DataWrapperByValue(Data data);

它按值获取参数，这意味着根据它是左值还是右值，它将调用data参数的副本或移动构造函数。特别是：如果它是一个左值，它会被复制。如果它是一个右值，它会被移动。

由于您通过 传递右值std::move(d2)，因此调用移动构造函数以移动d2到参数中。第二个移动构造函数调用当然是通过data_数据成员的初始化。

不幸的是，这里不能发生复制省略。如果移动很昂贵并且你想限制它们，你可以允许完美转发，这样至少有一个移动或一个副本：

template<class U>
DataWrapperByValue(U&& u) : data_(std::forward<U>(u)) { }
于 2014-03-15T16:55:51.957 回答
0

我相信这是因为您本质上是在执行此代码。

std::cout << "2. DataWrapperByValue:\n";  
Data d2;
DataWrapperByValue a2(Data(std::move(d2))); // Notice a Data object is constructed.

注意 DataWrapperByValue 只有一个接受左值的构造函数。当您执行 std::move(d2) 时，您正在传递一个 r 值，因此将创建另一个 Data 对象以传递给 DataWrapperByValue 构造函数。这个是使用 Data(Data&&) 构造函数创建的。然后在 DataWrapperByValue 的构造函数期间调用第二个移动构造函数。

于 2014-03-15T16:11:52.890 回答