confronto l'overloading degli operatori

Question

Qual è la migliore prassi (in questo caso):

bool Foo::operator==(const Foo& other) { 
    return bar == other.bar; 
} 

// Implementation 1 
bool Foo::operator!=(const Foo& other) { 
    return bar != other.bar 
} 

// Implementation 2 
bool Foo::operator!=(const Foo& other) { 
    return !(*this == other); 
} 

Per operatori come>, <, < =,> = vorrei andare con implementazione 2, quando possibile. Tuttavia, per! = Penso che l'implementazione 1 sia migliore poiché non viene effettuata un'altra chiamata al metodo, è corretto?

Answer 1

La seconda implementazione ha il notevole vincolo che == sarà sempre il contrario booleano di !=. Questo è probabilmente ciò che desideri e rende il tuo codice più facile da mantenere perché devi solo cambiare un'implementazione per mantenere i due sincronizzati.

Answer 2

È necessario utilizzare sempre ciò che si ha quando si sovraccaricano gli operatori di confronto. Gli unici due che dovresti definire sono operator== e operator<. Il resto puoi scrivere in termini di questi due. È meno soggetto a errori, come se si avesse un errore, è solo in un posto.

Una delle caratteristiche principali di OOP è la riusabilità del codice. Se hai già scritto il codice, perché scrivere di nuovo? Rimani fedele a ciò che hai e avrai solo una cosa da testare.

È piuttosto come dichiarare una costante e quindi utilizzarla in diversi punti del file.

Answer 3

L'implementazione 2 è migliore perché utilizza l'operatore già definito ==. Anche quelle funzioni dell'operatore dovrebbero essere const perché non modificano l'oggetto.

Answer 4

In generale, l'implementazione 2 è migliore per molte ragioni. Prima di tutto, non scrivi (quasi) codice duplicato. Se hai bisogno di cambiarlo (perché la classe è cresciuta o c'è stato un bug), di nuovo con l'implementazione 2 cambi solo 1 posto. In altre parole, l'implementazione 2 rende il codice più coerente e meno soggetto a errori.

Answer 5

Nessuno dei precedenti.

Vorrei poter trovare la carta che supera davvero questo dettaglio ma non riesco a ricordare il nome.

Le operazioni di confronto devono essere esterne. La tua interfaccia dovrebbe essere sufficiente per trovare lo stato di un oggetto e lo stato dell'oggetto dovrebbe essere il dettare il confronto. Dovrebbe essere possibile scrivere "uguali" al di fuori della vostra classe, e quindi qualsiasi confronto in realtà, e che sia possibile ... lo si desidera.