Как определить (перегрузить) симметричный двоичный оператор между двумя классами в C++, принимая во внимание значения r?

Question

То, что я хочу иметь: R = V + R = R + V. Как это сделать:

R operator+(const R &r, const V &v) { return R(r) += v; } 
R operator+(R &&r, const V &v) { return R(r) += v; } 
R operator+(const R &r, V &&v) { return R(r) += v; } 
R operator+(R &&r, V &&v) { return R(r) += v; } 

R operator+(const V &v, const R &r) { return r + v; } 
R operator+(V &&v, const R &r) { return r + v; } 
R operator+(const V &v, R &&r) { return r + v; } 
R operator+(V &&v, R &&r) { return r + v; } 

Есть ли более короткий путь?

Answer 1

Поскольку вы будете создавать экземпляр r либо из const R& или R&& в любом случае, это будет сократить на 4 линии:

R operator+(R r, const V& v) { return std::move(r += v); } 
R operator+(R r, V&& v) { return std::move(r += std::move(v)); } 

R operator+(const V& v, R r) { return std::move(r += v); } 
R operator+(V&& v, R r) { return std::move(r += std::move(v)); } 

Однако, я думаю, что это достаточно для вас во всех случаях, если ваш R::operator+=(V&&) нет разницы реализация от R::operator+=(const V&):

R operator+(R r, const V& v) { return std::move(r += v); } 

R operator+(const V& v, R r) { return std::move(r += v); } 

---

Мой ответ был ш когда я не знал об этой реализации:

R operator+=(R&& r, const V& v) 
R operator+=(R&& r, V&& v) 

Ответ Yakk лучше, если учитывать эти функции.

Answer 2

Предполагая:

R& operator+=(R& r, const V& v); 
R& operator+=(R& r, V&& v); 
R operator+=(R&& r, const V& v) { r += v; return std::move(r); } 
R operator+=(R&& r, V&& v) { r += std::move(v); return std::move(r); } 

мы должны иметь:

R operator+(R r, V const& v) { return std::move(r)+=v; } 
R operator+(R r, V && v) { return std::move(r)+=std::move(v); } 
R operator+(V const& v, R r) { return std::move(r)+=v; } 
R operator+(V && v, R r) { return std::move(r)+=std::move(v); } 

где я предполагаю, что R дешев передвигающийся, в то время как += с V&& лишь незначительно более эффективным, чем V const&.

Обратите внимание, что возвращаемое значение R operator+=(R&& r, ?) должно быть значением. Я реализую его в терминах +=(const&,?), а затем просто перейду в возвращаемое значение.

Это означает, что вы должны реализовать два оператора += за пределами вышеуказанного шаблона.

Если нет никакой выгоды от перемещенного-от V мы получаем:

R& operator+=(R& r, const V& v); 
R operator+=(R&& r, const V& v) { r += v; return std::move(r); } 
R operator+(R r, V const& v) { return std::move(r)+=v; } 
R operator+(V const& v, R r) { return std::move(r)+=v; } 

3 шаблонные, одна фактически реализовано функции.

Если вы не любите R operator+=(R&& r, const V& v) мы можем переписать это так:

R& operator+=(R& r, const V& v); 
R operator+(R r, V const& v) { return std::move(r+=v); } 
R operator+(V const& v, R r) { return std::move(r+=v); } 

и аналогично для V&& случаях, если это необходимо:

R& operator+=(R& r, V&& v); 
R operator+(R r, V&& v) { return std::move(r+=std::move(v)); } 
R operator+(V&& v, R r) { return std::move(r+=std::move(v)); } 

Мы делаем копию R в подписи operator+, а чем внутренне; если мы все равно его скопируем, возможно, также сделаем это в подписи.

Want speed? Pass by value. - это метод, используемый для удаления перегрузок R const& и R&& как избыточных.