C++ operatore == sovraccarico

Question

Eventuali duplicati:
Operator overloading

Qual è la differenza tra le seguenti modalità di sovraccaricare operatore ==?

// stroustrup way 
friend bool operator== (MyClass &lhs, MyClass &rhs); 

e

// as taught in other places, including caltech 
bool MyClass::operator== (MyClass &rhs); 

Da che parte è meglio?

Answer 1

Questo:

friend bool operator== (MyClass &lhs, MyClass &rhs); 

è una funzione che confronta due oggetti.

Questo:

bool MyClass::operator== (MyClass &rhs); 

è una funzione membro.

Si consiglia di utilizzare quello proposto dallo standard di codifica o utilizzare quello desiderato. Nessuno è migliore. Alcune persone (me compreso) preferiscono avere l'operatore di confronto come una funzione, altri preferiscono come funzione membro.

A proposito, i parametri devono essere del tipo const MyClass &.

Answer 2

La prima è la funzione amico esterna (funzione libera)

friend bool operator== (MyClass &lhs, MyClass &rhs); 

La seconda è la funzione di membro

bool MyClass::operator== (MyClass &rhs); 

Si dovrebbe usare la seconda variante sempre allora si può

Si dovrebbe usare prima variante in case: 1) Il primo argomento è la classe esterna (libreria)

friend ostream& operator<< (ostream &out, MyClass &m) 

2) la logica dell'operatore non correlati alla propria classe e deve essere implementato separatamente

friend bool operator(const MyClass& my, const std::string& string_form) 

(perché la vostra classe non può sapere tutto di classi che possono avere bisogno di confrontare le operatore)

Answer 3

// stroustrup way 
friend bool operator== (MyClass &lhs, MyClass &rhs); 

Gli argomenti devono essere const - friend bool operator==(const MyClass& lhs, const MyClass& rhs);. Questo è preferibile in quanto funziona quando il primo argomento può essere costruito implicitamente. Ad esempio, se std::string aveva solo una funzione membro operator==, quindi "abc" == my_std_string non la richiamerebbe! Ma, la funzione non membro può essere invocata costruendo implicitamente una stringa da "abc" (meglio ancora in questo caso particolare, è possibile fornire un separato bool operator==(const char*, const std::string&) per motivi di prestazioni, ma il punto rimane valido: le funzioni non associate possono aiutare a garantire l'operatore lavora con il tipo definito dall'utente su entrambi i lati).

Separatamente, i costruttori impliciti sono un po 'pericolosi - e si vuole riflettere sulla comodità rispetto al pericolo di usarli.