Wie wird in einem überladenen Operator auf die aktuelle Struktur verwiesen?

Question

Ich habe eine Struktur, für die ich eine relative Reihenfolge definieren möchte, indem ich <,>, < = und> = Operatoren definiere. tatsächlich in meiner Reihenfolge wird es keine Gleichheit geben, wenn also eine Struktur nicht kleiner als eine andere ist, ist sie automatisch größer.

ich den ersten Operator wie folgt definiert:

struct MyStruct{ 
... 
... 

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

}; 

nun die anderen Betreiber ich möchte auf diesem Operator, so dass < = das gleiche wie < und die beiden anderen wird einfach zurückkehren basierend definieren das Gegenstück zurückgeben. so zum Beispiel für den Operator> Ich mag würde so etwas wie

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

schreiben, aber ich weiß nicht, wie man diesen ‚Selbst‘ refere, da ich nur auf die Felder in der aktuellen Struktur refere kann.

Ganze ist in C++

hoffe, meine Frage war verständlich :)

danke für die Hilfe!

Answer 1

Selbst ist *this.

Das heißt, this ist ein Zeiger auf das aktuelle Objekt, so dass Sie es dereferenzieren müssen, um das tatsächliche Objekt zu erhalten.

Answer 2

Überladener Operator ist nur eine Member-Funktion, aber mit einer ausgefallenen Syntax. Sie können es explizit wie folgt aufrufen:

this->operator<(b); 

oder sich ein paar Haare speichern :) und bieten nur int compare(const MyStruct&) Funktionselement und verwenden, die in allen Drittvergleichsoperatoren.

Answer 3

Dies ist ein Zeiger auf Ihr aktuelles Objekt. Also (wie @Dave Hinton sagt) müsstest du es dereferenzieren. Aber, gibt eine weitere Option

zwei Optionen:

return !(*this<b) 

or 

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

Ja, die ersten ist ganz schöner.

Answer 4

tatsächlich in meiner Reihenfolge wird es keine Gleichheit geben, also wenn eine Struktur nicht kleiner als eine andere ist, ist es automatisch größer.

Das ist ein Problem. C++ - Operationen (und viele Algorithmen) erfordern eine strict weak ordering, was (unter anderem) bedeutet, dass x == x für jede x gilt. Ganz allgemein:

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

impliziert

x == y 

für jede x und y. Mit anderen Worten: Sie müssen höchstwahrscheinlich eine Art von Gleichheit für Ihre Struktur definieren, um mit jedem konventionellen Algorithmus zu arbeiten.

Answer 5

Wenn Sie eine operator< mit der entsprechenden Logik bereitstellen (unabhängig davon, ob sie als freie Funktion implementiert ist oder nicht), können Sie die anderen Operatoren als freie Funktionen implementieren. Dies folgt der Regel der Bevorzugung von Nichtmitgliedern über Mitglieder, wo dies möglich ist, und die freien Funktionen werden dasselbe Verhalten w.r.t. Konvertierungen der linken und rechten Operanden, während Operatoren, die als Elementfunktionen implementiert sind, nicht.

z.B.

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

ich oben mit Tom/Dave bin, dass in dem direkten Weg, dies zu schreiben:

return !(*this<b); 

aber für mich die ausdrücklich klar Form:

return !operator<(b); 

und Tom : zurück! (this-> operator < (b)); scheint ein wenig albern.

Dieses wenig böse C-Präprozessor-Code (Ich habe auch eine bessere, aber mehr technische Template-Lösung):

#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)); } 

automatisch alle Vergleichsoperatoren unter der Annahme definiert == und> definiert sind wie folgt:

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

Diese

Answer 7

wird als eine leichte Verbesserung gegenüber Element's answer gemeint:

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 */; } 
};