3

更新：明確化、より明確な焦点、および短縮された例：

  • 過負荷を回避できますM op+(M&&,M&&)か？仮に、RValuesを適切に処理したいですか？他の3つのオーバーロードが必要だと思います。

(&&,&&)そもそも私が過負荷になっている理由：

  • 通常は提供しませんがM op+(&&,&&)、必要なようです。オーバーロードを提供する(&&,&)と(&,&&)、コンパイラがあいまいになります。それを解決してから別の実装バリアントを追加するより良い方法はありますか？

完全なコードを確認することもできます。

struct Matrix {
...
  // 2ary ops
  friend Matrix operator+(const Matrix &a, Matrix &&b     ) { b+=a; return move(b); }
  friend Matrix operator+(Matrix &&a,      const Matrix &b) { a+=b; return move(a); }
  friend Matrix operator+(const Matrix &a, Matrix v)        { v+=a; return v; }
  friend Matrix operator+(Matrix &&a,      Matrix &&b)      { a+=b; return move(a); }
  // ... same for operator*
  // ... assume impl of operator+=,*= and move semantics
};

int main() {
  Matrix a{2},b{3},c{4},d{5};
  Matrix x = a*b + c*d;  // reuires &&,&& overload
  std::cout << x << std::endl;
}
4

2 に答える 2

2

次のヘルパー関数は、右辺値の場合は最初の値を返し、それ以外の場合は2番目の値を返します（右辺値の場合もありますが、そうでない場合もあります）。

template <class T1, class T2>
typename std::enable_if<! std::is_reference<T1>::value, T1&&>::type 
  get_rvalue(T1&& t1, T2&& t2) { return std::forward<T1>(t1); }

template <class T1, class T2>
typename std::enable_if<std::is_reference<T1>::value, T2&&>::type 
  get_rvalue(T1&& t1, T2&& t2) { return std::forward<T2>(t2); }

次のヘルパー関数は、上記で返されていない他の値を返します。

template <class T1, class T2>
typename std::enable_if<! std::is_reference<T1>::value, T1&&>::type 
  get_non_rvalue(T1&& t1, T2&& t2) { return std::forward<T2>(t2); }

template <class T1, class T2>
typename std::enable_if<std::is_reference<T1>::value, T2&&>::type 
  get_non_rvalue(T1&& t1, T2&& t2) { return std::forward<T1>(t1); }

これは、参照とconstを無視して、2つのタイプが同じであるかどうかを比較するだけです。

template <class T1, class T2>
struct is_same_decay : public std::is_same<
  typename std::decay<T1>::type, 
  typename std::decay<T2>::type
> {};

次に、次のように（テンプレートを使用して）関数ごとに1つのオーバーロードを実行できます。

// 2ary ops
template <class M1, class M2>
friend typename std::enable_if< 
  is_same_decay<M1, Matrix>::value &&
  is_same_decay<M2, Matrix>::value,
Matrix>::type
operator+(M1&& a, M2&& b) 
{ 
  Matrix x = get_rvalue(std::forward<M1>(a), std::forward<M2>(b)); 
  x += get_non_rvalue(std::forward<M1>(a), std::forward<M2>(b)); 
  return x; 
}

template <class M1, class M2>
friend typename std::enable_if< 
  is_same_decay<M1, Matrix>::value &&
  is_same_decay<M2, Matrix>::value,
Matrix>::type
operator*(M1&& a, M2&& b) 
{ 
  Matrix x = get_rvalue(std::forward<M1>(a), std::forward<M1>(b)); 
  x *= get_non_rvalue(std::forward<M1>(a), std::forward<M1>(b)); 
  return x; 
}

上記のように、M1またはM2が右辺値の場合、右辺値get_rvalue(a, b)が返されるため、この場合Matrix x、コピーではなく移動によってデータが入力されます。名前付きの戻り値の最適化により、戻り値の代わりに作成されるように、戻り値にコピー（または移動）する必要がないことが保証されxます。

完全なコードはここにあります。

于 2011-08-29T12:05:05.857 に答える
1 
Matrix& operator=(Matrix&& o) { swap(*this,o); };

まず、Matrixクラスには（現時点では）移動する必要のあるものがないため、わざわざ作成する必要はありません。コピーコンストラクターと同様に、必要な場合にのみ1つ定義します。正当な必要がない限り（裸のポインターを格納するなど）、コンパイラーに処理を任せてください。

第二に、あなたのその機能は動かない。スワップします。「慣用的な」スワップベースの移動には、次のような一時的なものが含まれます。

Matrix temp;
swap(o, temp);
swap(temp, *this);

friend Matrix operator+(const Matrix &a, Matrix &&b     ) { b+=a; return move(b); }
friend Matrix operator+(Matrix &&a,      const Matrix &b) { a+=b; return move(a); }
friend Matrix operator+(const Matrix &a, Matrix v)        { v+=a; return v; }
friend Matrix operator+(Matrix &&a,      Matrix &&b)      { a+=b; return move(a); }

ここで何を達成しようとしていますか？繰り返しますが、オブジェクトには移動するものはありません。これを行う意味はありません。何かを動かすことができるからといって、そうする必要があるという意味ではありません。本当にコードの重複を減らしたい場合は、通常どおりに実行します。

friend Matrix operator+(const Matrix &a, const Matrix &b) { Matrix temp = a + b; return temp; }
于 2011-08-24T10:33:43.970 に答える