comment faire référence à la structure actuelle dans un opérateur surchargé?

Question

J'ai une structure pour laquelle je veux définir un ordre relatif en définissant <,>, < = et> = opérateurs. En fait, dans ma commande, il n'y aura pas d'égalité, donc si une structure n'est pas plus petite qu'une autre, elle est automatiquement plus grande.

J'ai défini le premier opérateur comme celui-ci:

struct MyStruct{ 
... 
... 

bool operator < (const MyStruct &b) const {return (somefancycomputation);} 

}; 

maintenant je voudrais définir les autres opérateurs en fonction de cet opérateur, de sorte que < = retournera les mêmes que < et les deux autres seront tout simplement retourner l'oposite. donc par exemple pour l'opérateur> je voudrais écrire quelque chose comme

bool operator > (const MyStruct &b) const {return !(self<b);} 

mais je ne sais pas comment Référé à ce « moi » car je ne peux que refere aux champs à l'intérieur du struct actuel.

tout est en C++

espère que ma question était compréhensible :)

merci pour l'aide!

Answer 1

Auto est *this.

En d'autres termes, this est un pointeur vers l'objet actuel, vous devez donc le déréférencer pour obtenir l'objet réel.

Answer 2

Opérateur surchargé est juste une fonction de membre mais avec une syntaxe de fantaisie. Vous pouvez appeler explicitement comme ceci:

this->operator<(b); 

ou vous sauver quelques cheveux :) et simplement fournir int compare(const MyStruct&) fonction membre et l'utiliser dans tous les opérateurs de comparaison non-membres.

Answer 3

Ceci est un pointeur vers votre objet actuel. Donc (comme le dit @Dave Hinton), vous devrez le déréférencer. Mais, theres une autre option

Deux options:

return !(*this<b) 

or 

return (!this->operator<(b)) 

Oui, le premier est tout à fait agréable.

Answer 4

effectivement dans ma commande il n'y aura pas d'égalité, donc si une structure n'est pas plus petite qu'une autre, elle est automatiquement plus grande.

C'est un problème. Les opérations C++ (et de nombreux algorithmes) nécessitent un strict weak ordering, ce qui (entre autres) implique que x == x est valable pour tout x. De manière plus générale:

not (x < y) and not (y < x) 

implique

x == y 

pour tout x et y. En d'autres termes: vous avez probablement devez définir une sorte d'égalité pour que votre structure fonctionne avec n'importe quel algorithme conventionnel.

Answer 5

Si vous fournissez un operator< avec toute la logique appropriée alors (qu'il soit ou non implémenté en tant que fonction libre) vous pouvez implémenter les autres opérateurs comme des fonctions libres. Ceci suit la règle consistant à préférer les non-membres aux membres, lorsque cela est possible, et les fonctions libres auront un comportement identique. conversions des opérandes gauche et droit, alors que les opérateurs implémentés comme fonctions membres ne le font pas.

par exemple.

inline bool operator>(const MyStruct& a, const MyStruct&b) 
{ 
    return b < a; 
} 

inline bool operator<=(const MyStruct& a, const MyStruct&b) 
{ 
    return !(b < a); 
} 

inline bool operator>=(const MyStruct& a, const MyStruct&b) 
{ 
    return !(a < b); 
} 

Answer 6

Je suis avec Tom/Dave ci-dessus en ce que la manière directe d'écrire ceci:

return !(*this<b); 

mais pour moi la forme la plus explicitement clair:

return !operator<(b); 

et Tom : return! (this-> opérateur < (b)); semble un peu idiot.

Ce petit peu méchant C code préprocesseur (j'ai aussi une meilleure mais plus une solution de modèle technique):

#define CREATE_SYMETRIC_ORDINAL_OPERATORS(Type) \ 
int operator !=(Type X) {return !((*this)==X); } \ 
int operator <(Type X) {return !((*this)>=X); } \ 
int operator >=(Type X) {return (((*this)>X)||((*this)==X)); } \ 
int operator <=(Type X) {return (((*this)<X)||((*this)==X)); } 

définit automatiquement tous les opérateurs de comparaison en supposant == et> sont définis comme ceci:

class Comparable { 
    public: 
    int operator ==(Comparable B); 
    int operator >(Comparable B); 
    CREATE_SYMETRIC_OPERATORS(Comparable); 
}; 

Answer 7

C'est conçu comme une légère amélioration par rapport Element's answer:

template< class Derived > 
class Comparable { 
    public: 
    bool operator !=(const Derived& rhs) const 
    {return !(static_cast<Derived&>(*this) == rhs); } 

    bool operator <(const Derived& rhs) const 
    {return rhs < static_cast<Derived&>(*this); } 

    bool operator >=(const Derived& rhs) const 
    {return !(static_cast<Derived&>(*this) < rhs); } 

    bool operator <=(const Derived& rhs) const 
    {return !(static_cast<Derived&>(*this) > rhs); } 
}; 

struct MyStruct : public Comparable<MyStruct> { 
    bool operator ==(const MyStruct & rhs) const 
    {return /* whatever */; } 

    bool operator <(const MyStruct & rhs) const 
    {return /* whatever */; } 
};