C++, bir referans değerindeki tekli eksi operatörünü aşırı yüklemek mümkün mü?

Question

Bu iki yöntem arasında ayrım yapmak mümkün mü? , bu durumda mükemmel şekilde tekrar kullanılabilir hale geldiğinde bir rengin değişmemesi gerekir mi?

TYPE a; 
TYPE b = -a;  // unary operator- of a TYPE& aka lvalue ref 
TYPE c = -(a+b); // unary operator- of a TYPE&& aka rvalue ref 

Answer 1

Sen reference qualifier-s (veya standardında olduğu gibi ref-eleme) kullanabilir

http://coliru.stacked-crooked.com/a/40905649dc0c14e7

örnek:

#include <iostream> 
#include <string> 
#include <vector> 

class X 
{ 
    public: 
     int n; 
     X(const X&) = default; 
     X() : n(0) {} 
     X(int n) : n(n) {} 

     X operator-() const & // lvalue ref-qualifier 
     { 
     std::cout << "&\n"; 
     X x(-n); 
     return x; 
     } 

     X operator-() const && // rvalue ref-qualifier 
     { 
     std::cout << "&&\n"; 
     X x(-n); 
     return x; 
     }  

     friend X operator+(const X& lhs, const X& rhs) { 
      return X(lhs.n + rhs.n); 
     } 
}; 

int main() 
{ 
    X a; 
    X b = -a;  // unary operator- of a TYPE& aka lvalue ref 
    X c = -(a+b); 
} 

çıkışlar:

& 
&& 

Answer 2

şey gibi:

class Type 
{ 
public: 
    Type& operator -() && { std::cout << "rvalue\n"; return *this; } 
    Type& operator -() & { std::cout << "lvalue\n"; return *this; } 
}; 

Demo