Перегрузка C ++ 11 оператора `M + (M &&, M &&)`

Question

Обновление: уточнение, более четкий фокус и сокращенный пример:

• Можно ли обойти перегрузку M op+(M&&,M&&)? Предполагая, что мне нужна хорошая обработка RValues ​​?Я предполагаю, что остальные три перегрузки необходимы .

Причина, по которой у меня вообще перегрузка (&&,&&):

• Обычно я быне предоставить M op+(&&,&&), но мне, похоже, это нужно: при предоставлении перегрузок для (&&,&) и (&,&&) компилятор попадает в неоднозначность.Есть ли лучший способ решить эту проблему, чем добавить другой вариант реализации?

Вы также можете посмотреть код complete .

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;
}

Answer 1

Следующая вспомогательная функция возвращает первое значение, если оно является rvalue, в противном случае второе значение (которое может быть rvalue, но может и не быть).

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.

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

Тогда мы можем сделать только одну перегрузку для каждой функции (используя шаблоны), как показано ниже:

// 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 является r-значением, get_rvalue(a, b) возвратит r-значение, следовательно, в этом случае Matrix x будет заполнено движением, а не копией. Оптимизация именованного возвращаемого значения, вероятно, обеспечит отсутствие необходимости в копировании (или даже перемещении) возвращаемого значения, поскольку вместо возвращаемого значения будет создан x.

Полный код здесь .

Answer 2

Matrix& operator=(Matrix&& o) { swap(*this,o); };

Во-первых, в вашем классе Matrix нет ничего (пока что), которое нужно перемещать, поэтому вам не стоит его писать.Как и конструктор копирования, определяет только один, если вам нужно .Позвольте компилятору позаботиться об этом, если только у вас нет законной нужды (например, хранение голого указателя).

Во-вторых, ваша функция не движется;это свопы .«Идиоматический» ход, основанный на свопе, требует временного действия, такого как:

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; }