Comparison operators

Vergleicht die Argumente.

Zweiseitiger Vergleich

Der Zwei-Wege-Vergleichsoperator-Ausdruck hat die Form

Relationsoperatoren

Gleichheitsoperatoren

Eingebaute bidirektionale Vergleichsoperatoren

Für eingebaute zweistellige Vergleichsoperatoren werden Lvalue-zu-Rvalue-Konvertierungen , Array-zu-Zeiger-Konvertierungen (bis C++26) und Funktions-zu-Zeiger-Konvertierungen auf lhs und rhs angewendet.

Für eingebaute Zwei-Wege-Vergleichsoperatoren ist das Ergebnis ein bool Prvalue.

Eingebaute arithmetische Vergleichsoperationen

Wenn die konvertierten Operanden beide arithmetischen oder Enumerationstyp (scoped oder unscoped) haben, usual arithmetic conversions werden auf beide Operanden angewendet. Die Werte werden nach den Konvertierungen verglichen:

#include <iostream>
int main()
{
    static_assert(sizeof(unsigned char) < sizeof(int),
                  "Cannot compare signed and smaller unsigned properly");
    int a = -1;
    int b = 1;
    unsigned int c = 1;
    unsigned char d = 1;
    std::cout << std::boolalpha
              << "Comparing two signed values:\n"
                 " -1 == 1 ? " << (a == b) << "\n"
                 " -1 <  1 ? " << (a <  b) << "\n"
                 " -1 >  1 ? " << (a >  b) << "\n"
                 "Comparing signed and unsigned:\n"
                 // may issue different-signedness warning:
                 " -1 == 1 ? " << (a == c) << "\n"
                 // may issue different-signedness warning:
                 " -1 <  1 ? " << (a <  c) << "\n"
                 // may issue different-signedness warning:
                 " -1 >  1 ? " << (a >  c) << "\n"
                 "Comparing signed and smaller unsigned:\n"
                 " -1 == 1 ? " << (a == d) << "\n"
                 " -1 <  1 ? " << (a <  d) << "\n"
                 " -1 >  1 ? " << (a >  d) << '\n';
}

Comparing two signed values:
 -1 == 1 ? false
 -1 <  1 ? true
 -1 >  1 ? false
Comparing signed and unsigned:
 -1 == 1 ? false
 -1 <  1 ? false
 -1 >  1 ? true
Comparing signed and smaller unsigned:
 -1 == 1 ? false
 -1 <  1 ? true
 -1 >  1 ? false

Eingebaute Zeigergleichheitsvergleiche

Die konvertierten Operanden der Gleichheitsoperatoren == und != können ebenfalls den Typ std::nullptr_t haben, (seit C++11) Zeigertyp oder Zeiger-auf-Member-Typ sein.

Eingebaute Zeigergleichheitsvergleiche haben drei mögliche Ergebnisse: gleich, ungleich und nicht spezifiziert. Die von Gleichheitsoperatoren für eingebaute Zeigergleichheitsvergleiche gelieferten Werte sind unten aufgeführt:

Wenn mindestens einer der konvertierten lhs und rhs ein Zeiger ist, werden Zeigerkonvertierungen , Funktionszeigerkonvertierungen (seit C++17) und Qualifikationskonvertierungen auf beiden konvertierten Operanden durchgeführt, um sie auf ihren zusammengesetzten Zeigertyp zu bringen. Die beiden Zeiger des zusammengesetzten Zeigertyps werden wie folgt verglichen:

• Wenn ein Zeiger die Adresse eines vollständigen Objekts repräsentiert und ein anderer Zeiger

• repräsentiert die Adresse nach dem Ende eines anderen vollständigen Nicht-Array-Objekts, oder
• repräsentiert die Adresse eins nach dem letzten Element eines anderen vollständigen Array-Objekts,

das Ergebnis des Vergleichs ist nicht spezifiziert.

• Andernfalls, wenn die Zeiger beide null sind, beide auf dieselbe Funktion zeigen oder beide dieselbe Adresse repräsentieren (d.h. sie zeigen auf dasselbe Objekt oder sind hinter dessen Ende), vergleichen sie gleich.
• Andernfalls vergleichen die Zeiger ungleich.

Wenn mindestens einer der konvertierten lhs und rhs ein Zeiger auf Member ist, werden Pointer-to-Member-Konvertierungen , Function-Pointer-Konvertierungen (seit C++17) und Qualification-Konvertierungen auf beiden konvertierten Operanden durchgeführt, um sie auf ihren zusammengesetzten Zeigertyp zu bringen. Die beiden Zeiger auf Member des zusammengesetzten Zeigertyps werden wie folgt verglichen:

• Wenn zwei Zeiger auf Member beide den Null-Member-Zeigerwert haben, vergleichen sie gleich.
• Wenn nur einer von zwei Zeigern auf Member den Null-Member-Zeigerwert hat, vergleichen sie ungleich.
• Wenn einer von beiden ein Zeiger auf eine virtuelle Memberfunktion ist, ist das Ergebnis nicht spezifiziert.
• Wenn sich einer auf ein Member der Klasse C1 bezieht und der andere auf ein Member einer anderen Klasse C2 , wobei keine eine Basisklasse der anderen ist, ist das Ergebnis nicht spezifiziert.
• Wenn sich beide auf (möglicherweise verschiedene) Member derselben Union beziehen, vergleichen sie gleich.
• Andernfalls vergleichen zwei Zeiger auf Member gleich, wenn sie auf dasselbe Member desselben am meisten abgeleiteten Objekts oder desselben Unterobjekts verweisen würden, wenn eine Indirektion mit einem hypothetischen Objekt des zugehörigen Klassentyps durchgeführt würde, andernfalls vergleichen sie ungleich.

struct P {};
struct Q : P { int x; };
struct R : P { int x; };
int P::*bx = (int(P::*)) &Q::x;
int P::*cx = (int(P::*)) &R::x;
bool b1 = (bx == cx); // nicht spezifiziert
struct B
{
    int f();
};
struct L : B {};
struct R : B {};
struct D : L, R {};
int (B::*pb)() = &B::f;
int (L::*pl)() = pb;
int (R::*pr)() = pb;
int (D::*pdl)() = pl;
int (D::*pdr)() = pr;
bool x = (pdl == pdr); // falsch
bool y = (pb == pl);   // wahr

Eingebaute relationale Zeigervergleiche

Die konvertierten Operanden von relationalen Operatoren > , < , >= und <= können ebenfalls Pointer-Typ haben.

Eingebaute relationale Zeigervergleiche bei ungleichen Zeigern p und q haben drei mögliche Ergebnisse: p ist größer, q ist größer und unspezifiziert. Die Werte, die von relationalen Operatoren für eingebaute relationale Zeigervergleiche geliefert werden, sind unten aufgeführt:

Wenn der konvertierte lhs und rhs beide Zeiger sind, Zeigerkonvertierungen , Funktionszeigerkonvertierungen (seit C++17) und Qualifikationskonvertierungen werden auf beiden konvertierten Operanden durchgeführt, um sie auf ihren zusammengesetzten Zeigertyp zu bringen. Die beiden Zeiger des zusammengesetzten Zeigertyps werden wie folgt verglichen:

• Wenn die Zeiger gleich verglichen werden oder das Ergebnis des Gleichheitsvergleichs nicht spezifiziert ist, fällt das Ergebnis des relationalen Vergleichs in dieselbe Kategorie.
• Andernfalls (wenn die Zeiger ungleich verglichen werden), falls einer der Zeiger kein Zeiger auf ein Objekt ist, ist das Ergebnis nicht spezifiziert.
• Andernfalls (beide Zeiger zeigen auf Objekte), wird das Ergebnis definiert durch eine partielle Ordnung, die mit den folgenden Regeln konsistent ist:

• Gegeben zwei verschiedene Elemente high und low eines Arrays, wobei high einen höheren Index als low hat: Wenn ein Zeiger auf high (oder ein Unterobjekt von high ) zeigt und der andere Zeiger auf low (oder ein Unterobjekt von low ) zeigt, dann vergleicht sich der erstere als größer als der letztere.
• Wenn ein Zeiger auf ein Element elem (oder auf ein Unterobjekt von elem ) eines Arrays zeigt und der andere Zeiger über das Ende desselben Arrays hinauszeigt, dann vergleicht sich der Zeiger über das Ende hinaus als größer als der andere Zeiger.
• Wenn ein Zeiger auf ein vollständiges Objekt, ein Basisklassen-Unterobjekt oder ein Mitglieds-Unterobjekt obj (oder auf ein Unterobjekt von obj ) zeigt und der andere Zeiger über das Ende von obj hinauszeigt, dann vergleicht sich der Zeiger über das Ende hinaus als größer als der andere Zeiger.

• Wenn die Zeiger auf verschiedene nicht-null-große (seit C++20) nicht-statische Datenelemente mit demselben Elementzugriff (bis C++23) desselben Objekts eines Nicht-Union-Klassentyps zeigen, oder auf Unterobjekte solcher Elemente, rekursiv, dann vergleicht sich der Zeiger auf das später deklarierte Element größer als der andere Zeiger.
• Andernfalls ist das Ergebnis nicht spezifiziert.

Zeiger-Gesamtordnung

Es existiert eine implementierungsdefinierte strikte Totalordnung über Zeiger in jedem Programm. Die strikte Totalordnung ist konsistent mit der oben beschriebenen partiellen Ordnung: unspezifizierte Ergebnisse werden implementierungsdefiniert, während andere Ergebnisse gleich bleiben.

Zeigervergleich mit der strikten Totalordnung wird in den folgenden Fällen angewendet:

• Aufrufen des operator ( ) der Zeigertyp-Spezialisierungen von std::less , std::greater , std::less_equal , und std::greater_equal .

Überladungen

Bei Überlagerungsauflösung für benutzerdefinierte Operatoren nehmen für jedes Paar von heraufgestuften arithmetischen Typen L und R , einschließlich Aufzählungstypen, die folgenden Funktionssignaturen an der Überlagerungsauflösung teil:

Für jeden Typ P , der entweder ein Zeiger auf Objekt oder ein Zeiger auf Funktion ist, nehmen die folgenden Funktionssignaturen an der Überladungsauflösung teil:

Für jeden Typ MP , der ein Zeiger auf Mitgliedsobjekt oder Zeiger auf Mitgliedsfunktion ist oder std::nullptr_t (seit C++11) , nehmen die folgenden Funktionssignaturen an der Überladungsauflösung teil:

#include <iostream>
struct Foo
{
    int n1;
    int n2;
};
union Union
{
    int n;
    double d;
};
int main()
{
    std::cout << std::boolalpha;
    char a[4] = "abc";
    char* p1 = &a[1];
    char* p2 = &a[2];
    std::cout << "Pointers to array elements:\n"
              << "p1 == p2? " << (p1 == p2) << '\n'
              << "p1 <  p2? " << (p1 <  p2) << '\n';
    Foo f;
    int* p3 = &f.n1;
    int* p4 = &f.n2;
    std::cout << "Pointers to members of a class:\n"
              << "p3 == p4? " << (p3 == p4) << '\n'
              << "p3 <  p4? " << (p3 <  p4) << '\n';
    Union u;
    int* p5 = &u.n;
    double* p6 = &u.d;
    std::cout << "Pointers to members of a union:\n"
              << "p5 == (void*)p6? " << (p5 == (void*)p6) << '\n'
              << "p5 <  (void*)p6? " << (p5 <  (void*)p6) << '\n';
}

Pointers to array elements:
p1 == p2? false
p1 <  p2? true
Pointers to members of a class:
p3 == p4? false
p3 <  p4? true
Pointers to members of a union:
p5 == (void*)p6? true
p5 <  (void*)p6? false

#include <compare>
#include <iostream>
int main()
{
    double foo = -0.0;
    double bar = 0.0;
    auto res = foo <=> bar;
    if (res < 0)
        std::cout << "-0 is less than 0";
    else if (res > 0)
        std::cout << "-0 is greater than 0";
    else if (res == 0)
        std::cout << "-0 and 0 are equal";
    else
        std::cout << "-0 and 0 are unordered";
}

-0 and 0 are equal

Hinweise

Da Vergleichsoperatoren von links nach rechts gruppieren, wird der Ausdruck a < b < c als ( a < b ) < c geparst und nicht als a < ( b < c ) oder ( a < b ) && ( b < c ) .

#include <iostream>
int main()
{
    int a = 3, b = 2, c = 1;
    std::cout << std::boolalpha
        << (a < b < c) << '\n' // true; möglicherweise Warnung
        << ((a < b) < c) << '\n' // true
        << (a < (b < c)) << '\n' // false
        << ((a < b) && (b < c)) << '\n'; // false
}

Eine häufige Anforderung für user-defined operator< ist strict weak ordering . Insbesondere wird dies von den Standardalgorithmen und Containern benötigt, die mit Compare -Typen arbeiten: std::sort , std::max_element , std::map , etc.

Das Vergleichsergebnis von Zeigern auf verschiedene nicht-statische Datenelemente derselben Klasse impliziert, dass nicht-statische Datenelemente in jedem der drei Zugriffsmodi für Elemente (bis C++23) im Speicher in der Reihenfolge ihrer Deklaration positioniert sind.

Obwohl das Ergebnis des Vergleichs von Zeigern beliebigen Ursprungs (z.B. nicht alle zeigen auf Elemente desselben Arrays) nicht spezifiziert ist, bieten viele Implementierungen eine strenge Totalordnung von Zeigern, z.B. wenn sie als Adressen innerhalb eines kontinuierlichen virtuellen Adressraums implementiert sind. Jene Implementierungen, die dies nicht tun (z.B. wenn nicht alle Bits des Zeigers Teil einer Speicheradresse sind und für den Vergleich ignoriert werden müssen, oder eine zusätzliche Berechnung erforderlich ist oder sonst Zeiger und Integer keine 1-zu-1-Beziehung haben), bieten eine Spezialisierung von std::less für Zeiger an, die diese Garantie bietet. Dies ermöglicht es, alle Zeiger beliebigen Ursprungs als Schlüssel in standardmäßigen assoziativen Containern wie std::set oder std::map zu verwenden.

Für Typen, die sowohl EqualityComparable als auch LessThanComparable sind, trifft die C++-Standardbibliothek eine Unterscheidung zwischen Gleichheit , die durch den Wert des Ausdrucks a == b definiert ist, und Äquivalenz , die durch den Wert des Ausdrucks ! ( a < b ) && ! ( b < a ) definiert ist.

Der Vergleich zwischen Zeigern und Nullzeigerkonstanten wurde durch die Lösung von CWG Issue 583 entfernt, die in N3624 enthalten ist:

void f(char* p)
{
    if (p > 0) { /*...*/ } // Fehler mit N3624, kompilierte vor N3624
    if (p > nullptr) { /*...*/ } // Fehler mit N3624, kompilierte vor N3624
}
int main() {}

Der dreiseitige Vergleich kann automatisch für Klassentypen generiert werden, siehe default comparisons .

Wenn beide Operanden Arrays sind, ist der Drei-Wege-Vergleich fehlerhaft.

unsigned int i = 1;
auto r = -1 < i;    // Bestehende Fehlerquelle: gibt 'false' zurück
auto r2 = -1 <=> i; // Fehler: Einschränkende Konvertierung erforderlich

Standardbibliothek

Vergleichsoperatoren sind für viele Klassen in der Standardbibliothek überladen.

Der Namensraum std::rel_ops stellt generische Operatoren ! = , > , <= und >= bereit:

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

Siehe auch

• Operator-Präzedenz
• Operator-Überladung
• Compare (Named Requirements)