考虑以下代码:

#include <iostream>
#include <type_traits>

struct A
{
  A() {}
  A(const A&) { std::cout << "Copy" << std::endl; }
  A(A&&) { std::cout << "Move" << std::endl; }
};

template <class T>
struct B
{
  T x;
};

#define MAKE_B(x) B<decltype(x)>{ x }

template <class T>
B<T> make_b(T&& x)
{
  return B<T> { std::forward<T>(x) };
}

int main()
{
  std::cout << "Macro make b" << std::endl;
  auto b1 = MAKE_B( A() );
  std::cout << "Non-macro make b" << std::endl;
  auto b2 = make_b( A() );
}

Macro make b
Non-macro make b
Move

N3290 Final C++0x draft page 284:

This elision of copy/move operations, called copy elision, is permitted in the following circumstances:

when a temporary class object that has not been bound to a reference (12.2) would be copied/moved to a class object with the same cv-unqualified type, the copy/move operation can be omitted by constructing the temporary object directly into the target of the omitted copy/move

#include <iostream>
#include <type_traits>

struct A
{
  A() {}
  A(const A&) { std::cout << "Copy" << std::endl; }
  A(A&&) { std::cout << "Move" << std::endl; }
};

template <class T>
class B
{
public:
  template <class LAMBDA1, class LAMBDA2>
  B(const LAMBDA1& f1, const LAMBDA2& f2) : x1(f1()), x2(f2()) 
  { 
    std::cout 
    << "I'm a non-trivial, therefore not a POD.\n" 
    << "I also have private data members, so definitely not a POD!\n";
  }
private:
  T x1;
  T x2;
};

#define DELAY(x) [&]{ return x; }

#define MAKE_B(x1, x2) make_b(DELAY(x1), DELAY(x2))

template <class LAMBDA1, class LAMBDA2>
auto make_b(const LAMBDA1& f1, const LAMBDA2& f2) -> B<decltype(f1())>
{
  return B<decltype(f1())>( f1, f2 );
}

int main()
{
  auto b1 = MAKE_B( A(), A() );
}

最佳答案

正如 Anthony 已经提到的，标准禁止从函数的参数复制省略到同一个函数的返回。插入该决定的基本原理是复制省略(和移动省略)是一种优化，通过该优化，程序中的两个对象合并到同一内存位置，也就是说，通过使两个对象成为一个对象来省略拷贝。下面是(部分)标准引用，然后是一组允许复制省略的情况，其中不包括该特定情况。

那么是什么让这个特殊案例与众不同呢？区别基本上在于原始对象和复制对象之间存在函数调用这一事实，并且函数调用意味着需要考虑额外的约束，尤其是调用约定。

给定一个函数 T foo( T ) ，以及一位用户调用 T x = foo( T(param) ); , 一般情况下，单独编译，编译器会创建一个对象$tmp1在调用约定要求第一个参数的位置。然后它将调用该函数并初始化 x从返回语句。这是复制省略的第一个机会:小心放置x在返回的临时文件所在的位置，x以及从 foo 返回的对象成为单个对象，并且该拷贝将被省略。到现在为止还挺好。问题是调用约定通常不会将返回的对象和参数放在同一位置，因此，$tmp1和 x不能是内存中的单个位置。

如果没有看到函数定义，编译器就不可能知道函数参数的唯一目的是作为 return 语句，因此它不能省略那个额外的拷贝。可以说，如果函数是inline那么编译器就会有缺失的额外信息来理解用于调用函数的临时值、返回值和 x是单个对象。问题是该特定拷贝只有在代码实际内联时才能被省略(不仅当它被标记为 inline 但实际上是内联的)如果需要函数调用，那么拷贝不能被省略。如果标准允许在内联代码时省略该拷贝，则意味着程序的行为将因编译器而不是用户代码而有所不同——inline关键字不强制内联，仅表示同一函数的多个定义不代表违反 ODR。

请注意，如果变量是在函数内部创建的(与传入函数相比)，如:T foo() { T tmp; ...; return tmp; } T x = foo();那么两个拷贝都可以被省略:从哪里开始没有限制tmp必须创建(它不是函数的输入或输出参数，因此编译器能够将其重新定位到任何位置，包括返回类型的位置，在调用端，x 可以像前面的示例一样是仔细定位在同一个 return 语句的位置，这基本上意味着 tmp 、 return 语句和 x 可以是单个对象。

对于您的特定问题，如果您使用宏，则代码是内联的，对对象没有限制，并且可以省略拷贝。但是如果你添加一个函数，你不能从参数到 return 语句中删除拷贝。所以只是避免它。不要使用将移动对象的模板，而是创建一个将构造对象的模板:

template <typename T, typename... Args>
T create( Args... x ) {
   return T( x... );
}

When certain criteria are met, an implementation is allowed to omit the copy/move construction of a class object, even if the copy/move constructor and/or destructor for the object have side effects. In such cases, the implementation treats the source and target of the omitted copy/move operation as simply two different ways of referring to the same object, and the destruction of that object occurs at the later of the times when the two objects would have been destroyed without the optimization.

关于c++ - 如何允许 C++ 类的复制省略构造(不仅仅是 POD C 结构)，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/5877726/