L'utilizzo di unario più dell'operatore

Question

Ho sentito che viene utilizzato come operatore di overload + per esempio

class MyClass 
{ 
    int x; 
public: 
    MyClass(int num):x(num){} 
    MyClass operator+(const MyClass &rhs) 
    { 
     return rhs.x + x; 
    } 
}; 

int main() 
{ 
    MyClass x(100); 
    MyClass y(100); 
    MyClass z = x + y; 
} 

Questa è davvero l'uso di unario più dell'operatore o è davvero un operatore binario +?

Answer 1

questo non è sovraccarico e utilizzando unario + .. È necessario sia fare che una funzione libera o fare la funzione di membro prendere 0 argomenti

class MyClass 
{ 
    int x; 
public: 
    MyClass(int num):x(num){} 
    MyClass operator+() const 
    { 
     return *this; 
    } 
}; 

int main() { 
    MyClass x = 42; 
    + x; 
} 

Answer 2

Questo è un binario operatore +. Per sovraccaricare l'operatore unario più, avresti bisogno di something like this.

Answer 3

Quando una funzione operatore è una funzione membro, ha un argomento in più (this) rispetto a quanto esplicitamente menzionato nella dichiarazione. Quindi nel tuo caso è il + binario, il primo argomento è this, il secondo è l'argomento passato.

Answer 4

Questo è stato chiesto alcune volte prima.

L'operatore + è binario. Se definito come funzione membro deve essere const.

class MyClass 
{ 
    int x; 
public: 
    MyClass(int num):x(num){} 
    MyClass operator+(const MyClass &rhs) const 
    { 
     return rhs.x + x; 
    } 
}; 

E 'abbastanza spesso implementata in termini di operatori + =

Nota è stata attivata la proprietà commutativa ma funzionerà come + per int è commutativa.

Un operatore unario + come membro non accetta parametri e non modifica l'oggetto, pertanto dovrebbe essere const. L'implementazione dipende dal tuo oggetto. Potresti usarlo come "abs" per il tuo int. (Usarlo come no-op serve a poco).

MyClass MyClass::operator+() const 
    { 
     return (x >= 0) ? MyClass(x) : MyClass(-x); 
    }