Am 11.11.2017 nahm das ISO C ++ - Komitee den Vorschlag von Herb Sutter für den Dreiwege-Vergleichsoperator <=> "Raumschiff" als eine der neuen Funktionen an, die C ++ 20 hinzugefügt wurden . In dem Artikel mit dem Titel Konsistenter Vergleich Sutter demonstrieren Maurer und Brown die Konzepte des neuen Designs. Für einen Überblick über den Vorschlag hier ein Auszug aus dem Artikel:
Der Ausdruck a <=> b gibt ein Objekt zurück, das <0 vergleicht, wenn a <b , > 0 vergleicht, wenn a> b , und == 0 vergleicht, wenn a und b gleich / äquivalent sind.
Häufiger Fall: Um alle Vergleiche für Ihren Typ X mit Typ Y mit Mitgliedssemantik zu schreiben, schreiben Sie einfach:
auto X::operator<=>(const Y&) =default;
Erweiterte Fälle: Um alle Vergleiche für Ihren Typ X mit Typ Y zu schreiben, schreiben Sie einfach den Operator <=> , der ein Y annimmt. Verwenden Sie
= default , um bei Bedarf eine Semantik auf Mitgliedsebene abzurufen, und geben Sie den entsprechenden Kategorietyp zurück:
- Geben Sie eine _ordering zurück, wenn Ihr Typ natürlich < unterstützt und wir effizient symmetrische < , > , <= , > = , == und
! = Generieren . Andernfalls geben Sie eine _Equality zurück , und wir generieren effizient symmetrische == und ! = .
- Geben Sie strong_ zurück, wenn für Ihren Typ a == b f (a) == f (b) impliziert (Substituierbarkeit, wobei f nur den Vergleichsstatus liest, auf den mit den öffentlichen const- Mitgliedern zugegriffen werden kann ), andernfalls geben Sie
schwach_ zurück .
Vergleichskategorien
Fünf Vergleichskategorien werden als std::Typen definiert , die jeweils die folgenden vordefinierten Werte aufweisen:
+--------------------------------------------------------------------+
| | Numeric values | Non-numeric |
| Category +-----------------------------------+ |
| | -1 | 0 | +1 | values |
+------------------+------+------------+---------------+-------------+
| strong_ordering | less | equal | greater | |
| weak_ordering | less | equivalent | greater | |
| partial_ordering | less | equivalent | greater | unordered |
| strong_equality | | equal | nonequal | |
| weak_equality | | equivalent | nonequivalent | |
+------------------+------+------------+---------------+-------------+
Implizite Konvertierungen zwischen diesen Typen sind wie folgt definiert:
strong_orderingmit Werten { less, equal, greater} konvertiert implizit auf:
weak_orderingmit Werten { less, equivalent, greater}partial_orderingmit Werten { less, equivalent, greater}strong_equalitymit Werten { unequal, equal, unequal}weak_equalitymit Werten { nonequivalent, equivalent, nonequivalent}
weak_orderingmit Werten { less, equivalent, greater} konvertiert implizit auf:
partial_orderingmit Werten { less, equivalent, greater}weak_equalitymit Werten { nonequivalent, equivalent, nonequivalent}
partial_orderingmit Werten { less, equivalent, greater, unordered} konvertiert implizit auf:
weak_equalitymit Werten { nonequivalent, equivalent, nonequivalent, nonequivalent}
strong_equalitymit Werten { equal, unequal} wird implizit konvertiert in:
weak_equalitymit Werten { equivalent, nonequivalent}
Drei-Wege-Vergleich
Das <=>Token wird eingeführt. Die Zeichenfolge wird im alten Quellcode mit einem <=>Token versehen <= >. Muss beispielsweise X<&Y::operator<=>ein Leerzeichen hinzufügen, um seine Bedeutung beizubehalten.
Der überladbare Operator <=>ist eine Drei-Wege-Vergleichsfunktion und hat Vorrang höher als <und niedriger als <<. Es gibt einen Typ zurück, der mit Literal verglichen werden kann, 0aber andere Rückgabetypen sind zulässig, z. B. zur Unterstützung von Ausdrucksvorlagen. Alle <=>in der Sprache und in der Standardbibliothek definierten Operatoren geben einen der 5 oben genannten std::Vergleichskategorietypen zurück.
Für Sprachtypen werden die folgenden integrierten <=>Vergleiche desselben Typs bereitgestellt. Alle sind constexpr , sofern nicht anders angegeben. Diese Vergleiche können nicht heterogen mit skalaren Promotions / Conversions aufgerufen werden.
- Für
boolIntegral- und Zeigertypen wird <=>zurückgegeben strong_ordering.
- Bei Zeigertypen können die verschiedenen CV-Qualifikationen und Konvertierungen von abgeleiteten zu Basis eine homogene integrierte Funktion aufrufen
<=>, und es sind integrierte heterogene Funktionen vorhanden operator<=>(T*, nullptr_t). Nur Vergleiche von Zeigern auf dasselbe Objekt / dieselbe Zuordnung sind konstante Ausdrücke.
- Gibt für grundlegende Gleitkommatypen
<=>zurück partial_orderingund kann heterogen aufgerufen werden, indem Argumente auf einen größeren Gleitkommatyp erweitert werden.
- Gibt für Aufzählungen
<=>dasselbe zurück wie die zugrunde liegenden Typen der Aufzählung <=>.
- Für
nullptr_t, <=>kehrt strong_orderingund immer Ausbeuten equal.
- Gibt für kopierbare Arrays
T[N] <=> T[N]den gleichen Typ wie T's zurück <=>und führt einen lexikografischen elementweisen Vergleich durch. Es gibt keine <=>für andere Arrays.
- Denn
voides gibt keine <=>.
Zum besseren Verständnis der Funktionsweise von diesem Betreiber zu verstehen, benutzen Sie bitte das Original lesen Papier . Dies ist genau das, was ich mithilfe von Suchmaschinen herausgefunden habe.
