Breaking Änderung in C ++ 20 oder Regression in Clang-Trunk / Gcc-Trunk beim Überladen des Gleichheitsvergleichs mit nicht-booleschem Rückgabewert?

Der folgende Code lässt sich gut mit Clang-Trunk im C ++ 17-Modus kompilieren, bricht jedoch im C ++ 2a-Modus (bevorstehendes C ++ 20) ab:

// Meta struct describing the result of a comparison
struct Meta {};

struct Foo {
    Meta operator==(const Foo&) {return Meta{};}
    Meta operator!=(const Foo&) {return Meta{};}
};

int main()
{
    Meta res = (Foo{} != Foo{});
}

Es lässt sich auch gut mit gcc-trunk oder clang-9.0.0 kompilieren: https://godbolt.org/z/8GGT78

Der Fehler mit Clang-Trunk und -std=c++2a:

<source>:12:19: error: use of overloaded operator '!=' is ambiguous (with operand types 'Foo' and 'Foo')
    Meta res = (f != g);
                ~ ^  ~
<source>:6:10: note: candidate function
    Meta operator!=(const Foo&) {return Meta{};}
         ^
<source>:5:10: note: candidate function
    Meta operator==(const Foo&) {return Meta{};}
         ^
<source>:5:10: note: candidate function (with reversed parameter order)

Ich verstehe, dass C ++ 20 es möglich macht, nur zu überladen, operator==und der Compiler automatisch generiert, operator!=indem er das Ergebnis von negiert operator==. Soweit ich weiß, funktioniert dies nur, solange der Rückgabetyp ist bool.

Die Ursache des Problems ist , dass in Eigen wir eine Reihe von Operatoren erklären ==, !=, <, ... zwischen ArrayObjekten oder Arrayund Skalare, die Rückkehr (ein Ausdruck) ein Array von bool(die dann elementweise zugegriffen werden kann, oder anderweitig verwendet werden ). Z.B,

#include <Eigen/Core>
int main()
{
  Eigen::ArrayXd a(10);
  a.setRandom();
  return (a != 0.0).any();
}

Im Gegensatz zu meinem obigen Beispiel schlägt dies sogar mit gcc-trunk fehl: https://godbolt.org/z/RWktKs . Ich habe es noch nicht geschafft, dies auf ein Nicht-Eigen-Beispiel zu reduzieren, das sowohl im Clang-Trunk als auch im Gcc-Trunk fehlschlägt (das Beispiel oben ist ziemlich vereinfacht).

Zugehöriger Problembericht: https://gitlab.com/libeigen/eigen/issues/1833

Meine eigentliche Frage: Ist dies tatsächlich eine bahnbrechende Änderung in C ++ 20 (und besteht die Möglichkeit, die Vergleichsoperatoren zu überladen, um Meta-Objekte zurückzugeben), oder handelt es sich eher um eine Regression in clang / gcc?

Das Eigenproblem scheint sich auf Folgendes zu reduzieren:

using Scalar = double;

template<class Derived>
struct Base {
    friend inline int operator==(const Scalar&, const Derived&) { return 1; }
    int operator!=(const Scalar&) const;
};

struct X : Base<X> {};

int main() {
    X{} != 0.0;
}

Die beiden Kandidaten für den Ausdruck sind

1. der umgeschriebene Kandidat von operator==(const Scalar&, const Derived&)
2. Base<X>::operator!=(const Scalar&) const

Per [over.match.funcs] / 4 ist der Typ des impliziten Objektparameters für # 2 , da er operator!=nicht Xdurch eine using-Deklaration in den Gültigkeitsbereich von importiert wurde const Base<X>&. Infolgedessen hat # 1 eine bessere implizite Konvertierungssequenz für dieses Argument (exakte Übereinstimmung statt Konvertierung von abgeleitet zu Basis). Wenn Sie # 1 auswählen, wird das Programm schlecht geformt.

Mögliche Korrekturen:

• Hinzufügen using Base::operator!=;zu Derivedoder
• Ändern Sie das operator==, um a const Base&anstelle von a zu nehmen const Derived&.

Ja, der Code bricht tatsächlich in C ++ 20 ab.

Der Ausdruck Foo{} != Foo{}hat drei Kandidaten in C ++ 20 (während es in C ++ 17 nur einen gab):

Meta operator!=(Foo& /*this*/, const Foo&); // #1
Meta operator==(Foo& /*this*/, const Foo&); // #2
Meta operator==(const Foo&, Foo& /*this*/); // #3 - which is #2 reversed

Dies ergibt sich aus den neuen umgeschriebenen Kandidatenregeln in [over.match.oper] /3.4 . Alle diese Kandidaten sind lebensfähig, da unsere FooArgumente dies nicht sind const. Um den besten Kandidaten zu finden, müssen wir unsere Tiebreaker durchgehen.

Die relevanten Regeln für die bestmögliche Funktion lauten ab [over.match.best] / 2 :

In Anbetracht dieser Definitionen, eine tragfähige Funktion F1definierte eine bessere Funktion als eine andere tragfähige Funktion sein , F2wenn für alle Argumente i, als keine schlechte Umwandlungsfolge ist , und dann ICSi(F1)ICSi(F2)

• [... viele irrelevante Fälle für dieses Beispiel ...] oder, wenn nicht, dann
• F2 ist ein umgeschriebener Kandidat ([over.match.oper]) und F1 nicht
• F1 und F2 sind umgeschriebene Kandidaten, und F2 ist ein synthetisierter Kandidat mit umgekehrter Reihenfolge der Parameter und F1 nicht

#2und #3sind umgeschriebene Kandidaten und #3haben die Reihenfolge der Parameter umgekehrt, während sie #1nicht umgeschrieben werden. Aber um zu diesem Tiebreaker zu gelangen, müssen wir zuerst diese Anfangsbedingung durchstehen: Für alle Argumente sind die Konvertierungssequenzen nicht schlechter.

#1ist besser als #2weil alle Konvertierungssequenzen gleich sind (trivial, weil die Funktionsparameter gleich sind) und #2ein umgeschriebener Kandidat ist, während dies #1nicht der Fall ist.

Aber ... beide Paare #1/ #3und #2/ #3 bleiben bei dieser ersten Bedingung hängen. In beiden Fällen hat der erste Parameter eine bessere Konvertierungssequenz für #1/, #2während der zweite Parameter eine bessere Konvertierungssequenz für hat #3(der Parameter, constder einer zusätzlichen constQualifizierung unterzogen werden muss, hat also eine schlechtere Konvertierungssequenz). Dieses constFlip-Flop führt dazu, dass wir keines von beiden bevorzugen können.

Infolgedessen ist die gesamte Überlastungsauflösung nicht eindeutig.

Soweit ich weiß, funktioniert dies nur, solange der Rückgabetyp ist bool.

Das stimmt nicht Wir betrachten bedingungslos umgeschriebene und rückgängig gemachte Kandidaten. Die Regel, die wir haben, lautet aus [over.match.oper] / 9 :

Wenn ein umgeschriebener operator==Kandidat durch Überlastungsauflösung für einen Bediener ausgewählt wird @, muss sein Rückgabetyp cv sein bool

Das heißt, wir betrachten diese Kandidaten immer noch. Wenn jedoch der am besten geeignete Kandidat ein Kandidat ist operator==, der beispielsweise zurückkehrt, ist Metadas Ergebnis im Grunde das gleiche, als ob dieser Kandidat gelöscht worden wäre.

Wir wollten nicht in einem Zustand sein, in dem die Überlastungsauflösung den Rückgabetyp berücksichtigen müsste. Und auf jeden Fall ist die Tatsache, dass der Code hier zurückgegeben Metawird, unerheblich - das Problem würde auch bestehen, wenn er zurückgegeben wird bool.

Zum Glück ist die Lösung hier einfach:

struct Foo {
    Meta operator==(const Foo&) const;
    Meta operator!=(const Foo&) const;
    //                         ^^^^^^
};

Sobald Sie beide Vergleichsoperatoren erstellt haben const, gibt es keine Mehrdeutigkeit mehr. Alle Parameter sind gleich, daher sind alle Konvertierungssequenzen trivial gleich. #1würde jetzt #3durch nicht umgeschriebenes #2schlagen und würde jetzt #3durch nicht rückgängig gemacht schlagen - was #1den besten lebensfähigen Kandidaten macht. Das gleiche Ergebnis wie in C ++ 17, nur noch ein paar Schritte, um dorthin zu gelangen.

[over.match.best] / 2 listet auf, wie gültige Überladungen in einem Satz priorisiert werden. Abschnitt 2.8 sagt uns , dass F1besser als ist , F2wenn (unter vielen anderen Dingen):

F2ist ein umgeschriebener Kandidat ([over.match.oper]) und F1ist es nicht

Das Beispiel dort zeigt ein explizites operator<Aufrufen, obwohl operator<=>es vorhanden ist.

Und [over.match.oper] /3.4.3 sagt uns, dass die Kandidatur von operator==unter diesen Umständen ein umgeschriebener Kandidat ist.

Allerdings , Ihre Betreiber vergessen eine entscheidende Sache: sie sollten constFunktionen. Und wenn sie nicht verwendet werden const, kommen frühere Aspekte der Überlastungsauflösung ins Spiel. Keine der beiden Funktionen conststimmt genau überein, da constfür verschiedene Argumente Nicht- Konvertierungen durchgeführt werden müssen. Das verursacht die fragliche Mehrdeutigkeit.

Sobald Sie sie erstellt haben const, wird Clang Trunk kompiliert .

Ich kann nicht mit dem Rest von Eigen sprechen, da ich den Code nicht kenne, er sehr groß ist und daher nicht in eine MCVE passt.

Wir haben ähnliche Probleme mit unseren Goopax-Header-Dateien. Das Kompilieren des Folgenden mit clang-10 und -std = c ++ 2a erzeugt einen Compilerfehler.

template<typename T> class gpu_type;

using gpu_bool     = gpu_type<bool>;
using gpu_int      = gpu_type<int>;

template<typename T>
class gpu_type
{
  friend inline gpu_bool operator==(T a, const gpu_type& b);
  friend inline gpu_bool operator!=(T a, const gpu_type& b);
};

int main()
{
  gpu_int a;
  gpu_bool b = (a == 0);
}

Die Bereitstellung dieser zusätzlichen Operatoren scheint das Problem zu lösen:

template<typename T>
class gpu_type
{
  ...
  friend inline gpu_bool operator==(const gpu_type& b, T a);
  friend inline gpu_bool operator!=(const gpu_type& b, T a);
};