2016-06-09 14 views
13

ist es möglich, zwischen diesen beiden Methoden zu unterscheiden? sollte man einen rvalue nicht mutieren, wenn er in diesem Fall vollkommen wiederverwendbar erscheint?C++ ist es möglich, den unären Minus-Operator einer R-Wert-Referenz zu überladen?

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' '' und a + b 'sind L-Wert * * und * prvalue * (wenn Typ ist builtin oder dessen Operator '' + kehrt durch value); Sie sind keine Referenzen –

Antwort

14

können Sie verwenden reference qualifier-s (oder ref-Qualifikations wie in Standard)

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

Beispiel:

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

Ausgänge:

& 
&& 
11

Etwas wie:

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

Demo