Devo dichiarare manualmente> = e <= operatori?

Question

se ho già operatore> e operatore < definito (e operatore ==), ho bisogno di definire operatore> = e operatore < =, o sarà il compilatore li dichiarare per me se intenzionalmente non li dichiaro?

Inoltre, se ho operatore == definito, sarà il compilatore dichiarare operatore! = per me?

Answer 1

No, il compilatore non dichiarerà/definirà nessuno degli operatori che non hai definito manualmente. Tuttavia, Boost.Operators potrebbe essere di vostro gradimento - fa esattamente quello che volete che faccia il compilatore.

Answer 2

Il compilatore non farà nulla per sé per voi qui, ma è relativamente semplice per generare automaticamente ereditando dalla una classe adeguata, qualcosa di simile:

template< typename DerivedType > 
class ComparisonOperators 
{ 
public: 

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

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

    friend bool   operator>( 
          DerivedType const& lhs, 
          DerivedType const& rhs) 
    { 
     return rhs < lhs; 
    } 

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

protected: 
         ~ComparisonOperators() {} 
} ; 

Definire < e == nella tua classe, e derivano da questo, e avrai tutti gli operatori:

class MyClass : public ComparisonOperators<MyClass> 
{ 
    // ... 
public: 
    bool operator==(MyClass const& other) const; 
    bool operator<(MyClass const& other) const; 
    // ... 
}; 

Solo una nota: ho semplificato manualmente la versione che ho Actu Al uso, che definisce == e < pure, cerca il membro funzioni compare e isEqual, e usa compare per == e != quando non c'è isEqual. Non credo di aver introdotto errori , ma non si sa mai.

Answer 3

Qui ci sono già alcune buone risposte usando boost e l'ereditarietà. Ma come qualcuno ha notato - l'uso dell'ereditarietà per la creazione di un operatore sembra ... sbagliato.

Lo so #define s sono "taboo" in C++, ma è ancora quello che uso qui.

Ho un #define nella mia utilità generale comprendono che va come questo:

#define CREATE_COMPARITORS(name)        \ 
inline bool operator>(const name &o){return o<*this;}   \ 
inline bool operator<=(const name &o){return not (o<*this);} \ 
inline bool operator>=(const name &o){return not (*this<o);} \ 
inline bool operator!=(const name &o){return not (*this==o);} 

Poi se ho una classe, tutto quello che ho bisogno di dichiarare è operator< e operator==:

class ttt{ 
    //... 
    bool operator<(const ttt &o); 
    bool operator==(const ttt &o); 
    CREATE_COMPARITORS(ttt); 
    //... 
};