C ++ hat eine nette Redewendung, mit der man Klassen schreiben kann, die automatisch bestimmte Beziehungen zwischen Operatoren erfüllen. Dies erlaubt zum Beispiel die Definition vonoperator== und nicht die Mühe zu definiertenoperator!= auch. Dies ist die Idee hinter Boost.Operators.

Dies ist ein Beispiel

template<class Self> // this class is defined only once
struct equally_comparable{
    friend bool operator!=(Self const& s1, Self const& s2){return !(s1==s2);}
};

Diese Klasse kann wiederholt verwendet werden, um eine konsistente Logik zwischen @ zu erzwinge== und!= (und Fehler vermeiden)

struct A : equally_comparable<A>{ // 
    int value;
    A(int v) : value(v){}
    friend bool operator==(A const& a1, A const& a2){return a1.value == a2.value;}
};

int main(){

    A a1{4};
    A a2{4};
    assert(a1 == a2);
    A a3{5};
    assert(a1 != a3); // uses automatically generated operator !=
}

Nun, ich möchte eine Ebene weiter gehen und eine Klasse haben, die @ ähneequally_comparable und definiere dasander Funktion. Zum Beispiel wennoperator== ist definiert dann definiereoperator!= (wie oben), aber auch umgekehrt.

er erste naive Versuch klap

template<class Self>
struct equally_comparable{
    friend bool operator!=(Self const& s1, Self const& s2){return !(s1==s2);}
    friend bool operator==(Self const& s1, Self const& s2){return !(s1!=s2);}
};

, weil nur eine der beiden Funktionen in @ definiert werden mustruct A (entwederoperator== oderoperator!=). Es ist jedoch gefährlich, denn wenn man vergisst, einen der Operatoren in @ zu definierA Es gibt eine unendliche Rekursion (und einen Laufzeitfehler). Es sieht auch zerbrechlich aus.

Ist es möglich, dies zu verbessern und zu erkennen, dass zur Kompilierungszeit mindestens eine in der abgeleiteten Klasse definiert ist? oder allgemeiner gibt es eine generische Möglichkeit, eine Klasse zu haben, die die fehlenden Operatoren erzeugt? (d. h. einen Schritt weiter als Boost.Operators).