Esiste un equivalente del metodo Java equals in C++?

Question

C'è qualcosa come Java equals()? Per confrontare se l'oggetto è dello stesso tipo?

public boolean equals(Object obj) { 
    if (obj == null || !(obj instanceof ViewMode)) { 
     return false; 
    } 

    ViewMode dm = (ViewMode) obj; 
    return dm.width == w 
     && dm.h == h 
     && dm.b == b 
     && dm.f == f; 
} 

public int hashCode() { 
    return w^h^f^b ; 
} 

Answer 1

No. C++ non ha un modello di tipo globale come Java. Non esiste il tipo Object da cui ereditano tutti gli altri tipi, quindi non esistono metodi (come equals) definiti per tutte le classi.

C++ fornisce un framework per la costruzione di un modello di tipo con un'operazione di confronto universale: operator ==. Spetta a te costruire tutte le implementazioni di questo in tutte le tue classi in modo che interagiscano correttamente. Ma non esiste un'implementazione predefinita paragonabile a Object.equals.

Answer 2

È possibile definire il operator== nella classe.

Answer 3

Potrebbe essere possibile utilizzare l'operatore typeid per questo.

Answer 4

per l'equivalente idiomatico del vostro esempio, si potrebbe definire operator== come segue:

friend bool operator==(const ViewMode &lhs, const ViewMode &rhs) { 
    return (lhs.w == rhs.w) && the rest; 
} 

friend bool operator!=(const ViewMode &lhs, const ViewMode &rhs) { 
    return !(lhs == rhs); 
} 

In C++ non normalmente scrivere una funzione per consentire ViewMode oggetti da confrontare con qualcosa che non ha nulla a fare con ViewMode. Suppongo che se si voleva davvero che il confronto per tornare falso, piuttosto che il rifiuto di compilare, allora si potrebbe aggiungere un paio di operatori di template (come funzioni liberi, al di fuori della classe):

template <typename T> 
bool operator==(const ViewMode &, const T&) { 
    return false; 
} 

template <typename T> 
bool operator==(const T &, const ViewMode&) { 
    return false; 
} 

ma ho davvero don' lo consiglio Quel linguaggio Java non si applica a C++, perché in C++ praticamente non si dovrebbe mai avere un oggetto, ma non si ha idea del suo tipo.

Se si desidera che la funzione equals sia virtuale, è probabilmente preferibile scrivere una funzione virtuale equals() anziché utilizzare lo operator==. Scriverlo per prendere un parametro const ViewObject &, quindi non è necessario alcun equivalente al controllo instanceof. Il che è altrettanto valido, perché C++ non ha modo di prendere un oggetto di tipo totalmente sconosciuto e verificare se si tratta di un'istanza di un tipo specificato.

Raramente è necessaria una funzione di uguale in polimorfo in C++, ma se la si utilizza ad esempio in std::unordered_map, specificare i parametri di modello aggiuntivi su unordered_map. Dagli una funzione di confronto di uguaglianza che prende due indicatori e chiama equals su uno o l'altro e una funzione di hash che fa qualcosa di sensato.