Question

这与Matthieu M.提供的关于如何利用+运算符重载来利用移动语义的this answer有关（通常，不直接重新分配给左侧参数的运算符）。

他建议实施三种不同的重载：

inline T operator+(T left, T const& right) { left += right; return left; }
inline T operator+(T const& left, T right) { right += left; return right; } // commutative
inline T operator+(T left, T&& right) { left += right; return left; } // disambiguation

1号和3号是有道理的，但我不明白2的目的是什么。评论建议交换处理，但似乎1和2将是相互排斥的（即实现两个结果模糊）

例如，全部3实施：

T a, b, c;
c = a + b;

编译器输出：

1>          error C2593: 'operator +' is ambiguous
1>          could be 'T operator +(const T &,T)'
1>          or       'T operator +(T,const T &)'
1>          while trying to match the argument list '(T, T)'

删除1或2，程序按预期工作。由于1是一般情况，2只能与交换运算符一起正常工作，我不明白为什么2会被使用。有什么我想念的吗？

Answer 1

我认为你没有遗漏任何东西 - 你问题中的代码确实很麻烦。他的回答的早期部分是有道理的，但在“四个理想案例”和实际例子之间丢失了一些东西。

这可能更好：

inline T operator+(T left, T const& right) { left += right; return left; }
inline T operator+(const T& left, T&& right) { right += left; return right; }

这实现了规则：制作LHS的副本（最好通过移动构造），除非RHS到期，否则在适当的时候修改它。

对于非交换运算符，省略第二个重载，或者提供不委托给复合赋值的实现。

如果您的类内嵌了重量级资源（因此无法有效移动），您将希望避免按值传递。丹尼尔在答案中提出了一些好处。但是不要按照他的建议返回T&&，因为这是一个悬空参考。

Answer 2

关于此答案的重要更新/警告！

实际上是一个convincing example，它使用以下内容在合理的真实世界代码中静默创建悬空引用。请使用其他答案的技巧来避免此问题，即使以创建一些额外临时值为代价也是如此。我将保留此答案的其余部分，以备将来参考。

可交换案例的正确重载是：

T   operator+( const T& lhs, const T& rhs )
{
  T nrv( lhs );
  nrv += rhs;
  return nrv;
}

T&& operator+( T&& lhs, const T& rhs )
{
  lhs += rhs;
  return std::move( lhs );
}

T&& operator+( const T& lhs, T&& rhs )
{
  rhs += lhs;
  return std::move( rhs );
}

T&& operator+( T&& lhs, T&& rhs )
{
  lhs += std::move( rhs );
  return std::move( lhs );
}

为什么这样，它是如何工作的？首先，请注意，如果将rvalue引用作为参数，则可以修改并返回它。它来自的表达式需要保证在完整表达式结束之前不会破坏rvalue，包括operator+。这也意味着operator+可以简单地返回rvalue引用，因为调用者需要在表达式完全使用之前使用operator+的结果（它是相同表达式的一部分）评估和临时（ravlues）被破坏。

第二个重要的观察是，如何节省更多临时工和移动操作。请考虑以下表达式：

T a, b, c, d; // initialized somehow...

T r = a + b + c + d;

与上述相同，它相当于：

T t( a );    // T operator+( const T& lhs, const T& rhs );
t += b;      // ...part of the above...
t += c;      // T&& operator+( T&& lhs, const T& rhs );
t += d;      // T&& operator+( T&& lhs, const T& rhs );
T r( std::move( t ) ); // T&& was returned from the last operator+

将此与其他方法的情况进行比较：

T t1( a );   // T operator+( T lhs, const T& rhs );
t1 += b;     // ...part of the above...
T t2( std::move( t1 ) ); // t1 is an rvalue, so it is moved
t2 += c;
T t3( std::move( t2 ) );
t3 += d;
T r( std::move( t3 );

这意味着你仍然有三个临时工，虽然他们被移动而不是被复制，但上述方法在完全避免临时工作方面更有效。

要获得完整的库，包括对noexcept的支持，请参阅df.operators。在那里，您还可以找到非交换案例和混合类型操作的版本。

这是一个完整的测试程序来测试它：

#include <iostream>
#include <utility>

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

  A& operator+=( const A& ) { std::cout << "+=" << std::endl; return *this; }
};

// #define BY_VALUE
#ifdef BY_VALUE
A operator+( A lhs, const A& rhs )
{
  lhs += rhs;
  return lhs;
}
#else
A operator+( const A& lhs, const A& rhs )
{
  A nrv( lhs );
  nrv += rhs;
  return nrv;
}

A&& operator+( A&& lhs, const A& rhs )
{
  lhs += rhs;
  return std::move( lhs );
}
#endif

int main()
{
  A a, b, c, d;
  A r = a + b + c + d;
}

移动语义和运算符重载

2 个答案:

关于此答案的重要更新/警告！