2016-06-09 47 views
13

è possibile distinguere tra questi due metodi? non si dovrebbe mutare un rvalue quando in questo caso sembra perfettamente riutilizzabile?C++ è possibile sovraccaricare l'operatore unario meno di un riferimento di rvalue?

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 
+0

'' a' e un + b' sono * Ivalue * e * prvalue * (se TYPE è incorporata o suoi '' operatore + ritorna per valore); non sono riferimenti –

risposta

14

È possibile utilizzare reference qualifier-s (o REF-qualificazioni come nella serie)

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

esempio:

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

uscite:

& 
&& 
11

Qualcosa di simile:

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

Demo