Namensräume
Varianten
Aktionen

Vergleichsoperatoren

Von cppreference.com
< cpp‎ | Sprache
 
C++
 
C++ Sprache
Allgemeine Themen
Kontrollfluss
Bedingte Ausführungsaussagen
if
Iterationsanweisungen (Schleifen)
for
Bereichs-for (C++11)
Sprunganweisungen
Funktionen
Funktionsdeklaration
Lambda-Funktionsausdruck
inline-Spezifizierer
Dynamische Ausnahmespezifikationen (bis C++17*)
noexcept-Spezifizierer (C++11)
Ausnahmen
Namensräume
Typen
Spezifizierer
const/volatile
decltype (C++11)
auto (C++11)
constexpr (C++11)
consteval (C++20)
constinit (C++20)
Speicherdauer-Spezifizierer
Initialisierung
Ausdrücke
Alternative Darstellungen
Literale
Boolesch - Ganzzahl - Gleitkommazahl
Zeichen - String - nullptr (C++11)
Benutzerdefinierte (C++11)
Dienstprogramme
Attribute (C++11)
Typen
typedef-Deklaration
Typalias-Deklaration (C++11)
Umwandlungen
Speicherzuweisung
Klassen
Klassenspezifische Funktionseigenschaften
explicit (C++11)
static

Spezielle Member-Funktionen
Templates
Sonstiges
 
Ausdrücke
Allgemein
Literale
Operatoren
Konvertierungen
 

Vergleicht die Argumente.

Operatorname  Syntax  Überladbar Prototypenbeispiele (für class T)
Innerhalb der Klassendefinition Außerhalb der Klassendefinition
Gleich a == b Ja bool T::operator==(const U& b) const; bool operator==(const T& a, const U& b);
Ungleich a != b Ja bool T::operator!=(const U& b) const; bool operator!=(const T& a, const U& b);
Kleiner als a < b Ja bool T::operator<(const U& b) const; bool operator<(const T& a, const U& b);
Größer als a > b Ja bool T::operator>(const U& b) const; bool operator>(const T& a, const U& b);
Kleiner als oder gleich a <= b Ja bool T::operator<=(const U& b) const; bool operator<=(const T& a, const U& b);
Größer als oder gleich a >= b Ja bool T::operator>=(const U& b) const; bool operator>=(const T& a, const U& b);
Drei-Wege-Vergleich (C++20) a <=> b Ja R T::operator<=>(const U& b) const;[1] R operator<=>(const T& a, const U& b);[1]
Anmerkungen
  • Wo eingebaute Operatoren bool zurückgeben, geben die meisten benutzerdefinierten Überladungen ebenfalls bool zurück, damit die benutzerdefinierten Operatoren auf dieselbe Weise wie die eingebauten verwendet werden können. Bei einer benutzerdefinierten Operatorüberladung kann jedoch jeder Typ als Rückgabetyp verwendet werden (einschließlich void).
  • U kann jeder Typ sein, einschließlich T.
  1. ↑ 1.0 1.1 R ist der Rückgabetyp von operator<=> (siehe unten)

Inhalt

[bearbeiten] Zwei-Wege-Vergleich

Die Ausdrücke des Zwei-Wege-Vergleichsoperators haben die Form

[bearbeiten] Relationale Operatoren
lhs < rhs (1)
lhs > rhs (2)
lhs <= rhs (3)
lhs >= rhs (4)
[bearbeiten] Gleichheitsoperatoren
lhs == rhs (5)
lhs != rhs (6)
1) Gibt true zurück, wenn lhs kleiner als rhs ist, andernfalls false.
2) Gibt true zurück, wenn lhs größer als rhs ist, andernfalls false.
3) Gibt true zurück, wenn lhs kleiner als oder gleich rhs ist, andernfalls false.
4) Gibt true zurück, wenn lhs größer als oder gleich rhs ist, andernfalls false.
5) Gibt true zurück, wenn lhs gleich rhs ist, andernfalls false.
6) Gibt true zurück, wenn lhs ungleich rhs ist, andernfalls false.

[bearbeiten] Eingebaute Zwei-Wege-Vergleichsoperatoren

Bei eingebauten Zwei-Wege-Vergleichsoperatoren werden Lvalue-zu-Rvalue-Konvertierungen, Array-zu-Pointer-Konvertierungen(bis C++26) und Funktions-zu-Pointer-Konvertierungen auf lhs und rhs angewendet .

Der Vergleich wird abgewertet, wenn beide lhs und rhs einen Array-Typ haben, bevor diese Konvertierungen angewendet werden.

 (seit C++20)
(bis C++26)

Bei eingebauten relationalen Operatoren wird, wenn einer der Operanden ein Zeiger ist, die Array-zu-Pointer-Konvertierung auf den anderen Operanden angewendet.

Bei eingebauten Gleichheitsoperatoren wird, wenn einer der Operanden ein Zeiger oder eine Null-Zeiger-Konstante ist, die Array-zu-Pointer-Konvertierung auf den anderen Operanden angewendet.

 (seit C++26)

Bei eingebauten Zwei-Wege-Vergleichsoperatoren ist das Ergebnis ein bool-Prvalue.

[bearbeiten] Eingebaute arithmetische Vergleiche

Wenn beide konvertierten Operanden einen arithmetischen oder Aufzählungstyp (geschachtelt oder ungeschachtelt) haben, werden übliche arithmetische Konvertierungen auf beide Operanden angewendet. Die Werte werden nach der Konvertierung verglichen

Führen Sie diesen Code aus
#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';
}

Ausgabe

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

[bearbeiten] Eingebaute Pointer-Gleichheitsvergleiche

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

Eingebaute Pointer-Gleichheitsvergleiche haben drei mögliche Ergebnisse: gleich, ungleich und nicht spezifiziert. Die Werte, die von Gleichheitsoperatoren für eingebaute Pointer-Gleichheitsvergleiche geliefert werden, sind unten aufgeführt

 Vergleichsergebnis 
von p und q		 Wert geliefert von
p == q p != q
equal true false
ungleich false true
nicht spezifiziert  nicht spezifizierter bool-Wert 

Wenn mindestens einer der konvertierten lhs und rhs ein Zeiger ist, werden Pointer-Konvertierungen, Funktionspointer-Konvertierungen(seit C++17) und Qualifikationskonvertierungen auf beide konvertierten Operanden angewendet, um sie auf ihren gemeinsamen Zeigertyp zu bringen. Die beiden Zeiger des gemeinsamen Zeigertyps werden wie folgt verglichen

  • Wenn ein Zeiger die Adresse eines vollständigen Objekts repräsentiert und ein anderer Zeiger
  • die Adresse nach dem Ende eines anderen vollständigen Nicht-Array-Objekts repräsentiert, oder
  • die Adresse nach dem letzten Element eines anderen vollständigen Array-Objekts repräsentiert,
ist das Ergebnis des Vergleichs 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 über dessen Ende hinaus), vergleichen sie sich als gleich.
  • Andernfalls vergleichen sich die Zeiger als ungleich.

Wenn mindestens einer der konvertierten lhs und rhs ein Zeiger auf ein Mitglied ist, werden Zeiger-auf-Mitglied-Konvertierungen, Funktionspointer-Konvertierungen(seit C++17) und Qualifikationskonvertierungen auf beide konvertierten Operanden angewendet, um sie auf ihren gemeinsamen Zeigertyp zu bringen. Die beiden Zeiger auf Mitglieder des gemeinsamen Zeigertyps werden wie folgt verglichen

  • Wenn zwei Zeiger auf Mitglieder beide der Null-Mitgliedszeiger-Wert sind, vergleichen sie sich als gleich.
  • Wenn nur einer von zwei Zeigern auf Mitglieder der Null-Mitgliedszeiger-Wert ist, vergleichen sie sich als ungleich.
  • Wenn einer von ihnen ein Zeiger auf eine virtuelle Memberfunktion ist, ist das Ergebnis nicht spezifiziert.
  • Wenn einer sich auf ein Mitglied der Klasse C1 bezieht und der andere sich auf ein Mitglied einer anderen Klasse C2 bezieht, wobei keine die Basisklasse der anderen ist, ist das Ergebnis nicht spezifiziert.
  • Wenn sich beide auf (möglicherweise unterschiedliche) Mitglieder derselben union beziehen, vergleichen sie sich als gleich.
  • Andernfalls vergleichen sich zwei Zeiger auf Mitglieder als gleich, wenn sie auf dasselbe Mitglied desselben am weitesten abgeleiteten Objekts oder dasselbe Unterobjekt verweisen würden, wenn eine Indirektion mit einem hypothetischen Objekt des zugehörigen Klassentyps durchgeführt würde, andernfalls vergleichen sie sich als 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); // unspecified
 
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); // false
bool y = (pb == pl);   // true

Zwei Operanden vom Typ std::nullptr_t oder ein Operand vom Typ std::nullptr_t und der andere eine Null-Zeiger-Konstante vergleichen sich als gleich.

 (seit C++11)

[bearbeiten] Eingebaute Pointer-Relationalsvergleiche

Die konvertierten Operanden der relationalen Operatoren >, <, >= und <= können auch den Zeigertyp haben.

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

 Vergleichsergebnis 
von p und q		 Wert geliefert von
 p > q   p < q   p >= q   p <= q 
equal false false true true
p ist größer true false true false
q ist größer false true false true
nicht spezifiziert nicht spezifizierter bool-Wert

Wenn die konvertierten lhs und rhs beide Zeiger sind, werden Pointer-Konvertierungen, Funktionspointer-Konvertierungen(seit C++17) und Qualifikationskonvertierungen auf beide konvertierten Operanden angewendet, um sie auf ihren gemeinsamen Zeigertyp zu bringen. Die beiden Zeiger des gemeinsamen Zeigertyps werden wie folgt verglichen

  • Wenn die Zeiger gleich sind oder das Ergebnis des Gleichheitsvergleichs nicht spezifiziert ist, fällt das Ergebnis des relationalen Vergleichs in dieselbe Kategorie.
  • Andernfalls (die Zeiger vergleichen sich als ungleich), wenn einer der Zeiger kein Zeiger auf ein Objekt ist, ist das Ergebnis nicht spezifiziert.
  • Andernfalls (beide Zeiger zeigen auf Objekte), ist das Ergebnis im Sinne einer partiellen Ordnung definiert, die mit den folgenden Regeln übereinstimmt
  • Gegeben seien zwei unterschiedliche Elemente high und low eines Arrays, so dass 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, 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 hinausgeht, 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 hinausgeht, vergleicht sich der Zeiger über das Ende hinaus als größer als der andere Zeiger.

  • Wenn die Zeiger auf verschiedene nicht-Null-Größe(seit C++20) Nicht-Statik-Datenmitglieder mit demselben Zugriff(bis C++23) desselben Objekts eines Nicht-Union-Klassentyps oder auf Unterobjekte solcher Mitglieder, rekursiv, vergleicht sich der Zeiger auf das später deklarierte Mitglied als größer als der andere Zeiger.
  • Andernfalls ist das Ergebnis nicht spezifiziert.

[bearbeiten] Totalordnung für Pointer

Es existiert eine *implementierungsdefinierte strikte Totalordnung über Zeiger* in jedem Programm. Die strikte Totalordnung ist konsistent mit der partiellen Ordnung, die oben beschrieben wurde: Nicht spezifizierte Ergebnisse werden implementierungsdefiniert, während andere Ergebnisse unverändert bleiben.

Zeigervergleiche mit der strikten Totalordnung werden in den folgenden Fällen angewendet

(seit C++14)
(seit C++20)

[bearbeiten] Überladungen

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

bool operator<(L, R);
bool operator>(L, R);
bool operator<=(L, R);
bool operator>=(L, R);
bool operator==(L, R);
bool operator!=(L, R);

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

bool operator<(P, P);
bool operator>(P, P);
bool operator<=(P, P);
bool operator>=(P, P);
bool operator==(P, P);
bool operator!=(P, P);

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

bool operator==(MP, MP);
bool operator!=(MP, MP);
Führen Sie diesen Code aus
#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';
}

Ausgabe

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

Drei-Wege-Vergleich

Die Ausdrücke des Drei-Wege-Vergleichsoperators haben die Form

a <=> b

Der Ausdruck gibt ein Objekt zurück, so dass

  • (a <=> b) < 0 wenn a < b,
  • (a <=> b) > 0 wenn a > b,
  • (a <=> b) == 0 wenn a und b gleich/äquivalent sind.

Wenn einer der Operanden vom Typ bool ist und der andere nicht, ist das Programm ill-formed.

Wenn beide Operanden arithmetische Typen haben, oder wenn ein Operand einen ungeschachtelten Aufzählungstyp und der andere einen integralen Typ hat, werden die üblichen arithmetischen Konvertierungen auf die Operanden angewendet, und dann

  • Wenn eine Verengungskonvertierung erforderlich ist, außer von einem integralen Typ zu einem Fließkommatyp, ist das Programm ill-formed.
  • Andernfalls, wenn die Operanden einen integralen Typ haben, liefert der Operator einen Prvalue vom Typ std::strong_ordering
  • std::strong_ordering::equal wenn beide Operanden arithmetisch gleich sind,
  • std::strong_ordering::less wenn der erste Operand arithmetisch kleiner als der zweite ist,
  • std::strong_ordering::greater andernfalls.
  • Andernfalls haben die Operanden einen Fließkommatyp, und der Operator liefert einen Prvalue vom Typ std::partial_ordering. Der Ausdruck a <=> b liefert
  • std::partial_ordering::less wenn a kleiner als b ist,
  • std::partial_ordering::greater wenn a größer als b ist,
  • std::partial_ordering::equivalent wenn a äquivalent zu b ist (-0 <=> +0 ist äquivalent),
  • std::partial_ordering::unordered (NaN <=> anything ist unordered).

Wenn beide Operanden denselben Aufzählungstyp E haben, liefert der Operator das Ergebnis der Konvertierung der Operanden in den zugrunde liegenden Typ von E und der Anwendung von <=> auf die konvertierten Operanden.

Wenn mindestens einer der Operanden ein Zeiger auf ein Objekt oder ein Zeiger auf ein Mitglied ist, werden Array-zu-Pointer-Konvertierungen, Pointer-Konvertierungen und Qualifikationskonvertierungen auf beide Operanden angewendet, um sie auf ihren gemeinsamen Zeigertyp zu bringen.

Für konvertierte Zeigeroperanden p und q gibt p <=> q einen Prvalue vom Typ std::strong_ordering zurück

  • std::strong_ordering::equal wenn sie gleich sind,
  • std::strong_ordering::less, wenn q größer als p vergleicht,
  • std::strong_ordering::greater, wenn p größer als q vergleicht,
  • nicht spezifiziertes Ergebnis, wenn das Zwei-Wege-Vergleichsergebnis nicht spezifiziert ist.

Andernfalls ist das Programm fehlerhaft.

Überladungen

Bei der Auflösung von Überladungen für benutzerdefinierte Operatoren nimmt für Zeiger- oder Aufzählungstypen T die folgende Funktionssignatur an der Auflösung von Überladungen teil:

R operator<=>(T, T);

Wobei R der oben definierte Ordnungstyp ist.

Führen Sie diesen Code aus
#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";
}

Ausgabe

-0 and 0 are equal
 (seit C++20)

[bearbeiten] Hinweise

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

Führen Sie diesen Code aus
#include <iostream>
 
int main()
{
    int a = 3, b = 2, c = 1;
 
    std::cout << std::boolalpha
        << (a < b < c) << '\n' // true; maybe warning
        << ((a < b) < c) << '\n' // true
        << (a < (b < c)) << '\n' // false
        << ((a < b) && (b < c)) << '\n'; // false
}

Eine übliche Anforderung für benutzerdefinierte operator< ist eine strikte schwache Ordnung. Dies wird insbesondere von den Standardalgorithmen und Containern verlangt, die mit Compare-Typen arbeiten: std::sort, std::max_element, std::map usw.

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

Obwohl die Ergebnisse des Vergleichs von Zeigern beliebigen Ursprungs (z. B. nicht alle auf Member desselben Arrays zeigend) nicht spezifiziert sind, bieten viele Implementierungen eine strikte totale Ordnung von Zeigern, z. B. wenn sie als Adressen innerhalb eines kontinuierlichen virtuellen Adressraums implementiert sind. Diejenigen Implementierungen, die dies nicht tun (z. B. wo 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 Zeiger und Integer keine 1:1-Beziehung haben), stellen eine Spezialisierung von std::less für Zeiger bereit, die diese Garantie bietet. Dies ermöglicht die Verwendung aller Zeiger beliebigen Ursprungs als Schlüssel in Standard-assoziativen Containern wie std::set oder std::map.

Für Typen, die sowohl EqualityComparable als auch LessThanComparable sind, unterscheidet die C++-Standardbibliothek zwischen Gleichheit, dem Wert des Ausdrucks a == b, und Äquivalenz, dem Wert des Ausdrucks !(a < b) && !(b < a).

Der Vergleich zwischen Zeigern und Nullzeigerkonstanten wurde durch die Auflösung von CWG-Issue 583, enthalten in N3624, entfernt.

Führen Sie diesen Code aus
void f(char* p)
{
    if (p > 0) { /*...*/ } // Error with N3624, compiled before N3624
    if (p > nullptr) { /*...*/ } // Error with N3624, compiled before N3624
}
 
int main() {}

Ein Drei-Wege-Vergleich kann für Klassentypen automatisch generiert werden, siehe Standardvergleiche.

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

unsigned int i = 1;
auto r = -1 < i;    // existing pitfall: returns ‘false’
auto r2 = -1 <=> i; // Error: narrowing conversion required
Feature-Test-Makro Wert Std Feature
__cpp_impl_three_way_comparison 201907L (C++20) Drei-Wege-Vergleich (Compiler-Unterstützung)
__cpp_lib_three_way_comparison 201907L (C++20) Drei-Wege-Vergleich (Bibliotheksunterstützung); Hinzufügen des Drei-Wege-Vergleichs zur Bibliothek

[bearbeiten] Standardbibliothek

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

(in C++20 entfernt)
 prüft, ob die Objekte denselben Typ referenzieren
(public member function of std::type_info) [bearbeiten]
(entfernt in C++20)(entfernt in C++20)(C++20)
 vergleicht zwei error_codes
(function) [bearbeiten]
(entfernt in C++20)(entfernt in C++20)(C++20)
 vergleicht error_conditions und error_codes
(function) [bearbeiten]
(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(C++20)
 vergleicht die Werte im pair lexikographisch
(Funktionsvorlage) [edit]
(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(C++20)
 vergleicht die Werte im Tupel lexikographisch
(function template) [bearbeiten]
(in C++20 entfernt)
 vergleicht den Inhalt
(public member function of std::bitset<N>) [bearbeiten]
(in C++20 entfernt)
 vergleicht zwei Allocator-Instanzen
(public member function of std::allocator<T>) [bearbeiten]
(entfernt in C++20)(C++20)
 Vergleicht mit einem anderen unique_ptr oder mit nullptr
(Funktionsschablone) [bearbeiten]
(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(C++20)
 vergleicht mit einem anderen shared_ptr oder mit nullptr
(Funktionsschablone) [bearbeiten]
(in C++20 entfernt)
 vergleicht ein std::function mit nullptr
(function template) [edit]
(C++11)(C++11)(entfernt in C++20)(C++11)(C++11)(C++11)(C++11)(C++20)
 vergleicht zwei Dauern
(Funktionstemplate) [edit]
(C++11)(C++11)(entfernt in C++20)(C++11)(C++11)(C++11)(C++11)(C++20)
 vergleicht zwei Zeitpunkte
(Funktionstemplate) [edit]
(in C++20 entfernt)
 vergleicht zwei scoped_allocator_adaptor Objekte
(Funktionsschablone) [edit]
(entfernt in C++20)(C++20)
 vergleicht die zugrundeliegenden std::type_info-Objekte
(public member function of std::type_index) [bearbeiten]
(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(C++20)
 vergleicht zwei Strings lexikographisch
(function template) [edit]
(in C++20 entfernt)
 Gleichheitsvergleich zwischen Locale-Objekten
(public member function of std::locale) [bearbeiten]
(C++11)(C++11)(entfernt in C++20)(C++11)(entfernt in C++20)(C++11)(entfernt in C++20)(C++11)(entfernt in C++20)(C++11)(entfernt in C++20)(C++20)
 vergleicht die Werte zweier arrays lexikographisch
(function template) [edit]
(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(C++20)
 vergleicht die Werte zweier deques lexikographisch
(function template) [edit]
(C++11)(C++11)(entfernt in C++20)(C++11)(entfernt in C++20)(C++11)(entfernt in C++20)(C++11)(entfernt in C++20)(C++11)(entfernt in C++20)(C++20)
 vergleicht lexikographisch die Werte von zwei forward_lists
(function template) [edit]
(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(C++20)
 vergleicht die Werte von zwei lists lexikographisch
(function template) [edit]
(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(C++20)
 vergleicht lexikographisch die Werte zweier vectors
(function template) [edit]
(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(C++20)
 vergleicht zwei maps lexikographisch
(function template) [edit]
(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(C++20)
 vergleicht lexikographisch die Werte zweier multimaps
(function template) [edit]
(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(C++20)
 vergleicht die Werte von zwei sets lexikografisch
(function template) [edit]
(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(C++20)
 vergleicht die Werte von zwei multisets lexikographisch
(function template) [edit]
(C++11)(C++11)(entfernt in C++20)
 vergleicht die Werte in der unordered_map
(function template) [edit]
(C++11)(C++11)(entfernt in C++20)
 vergleicht die Werte in der unordered_multimap
(function template) [edit]
(C++11)(C++11)(entfernt in C++20)
 vergleicht die Werte im unordered_set
(function template) [edit]
(C++11)(C++11)(entfernt in C++20)
 vergleicht die Werte im unordered_multiset
(function template) [edit]
(C++20)
 vergleicht lexikographisch die Werte zweier queues
(function template) [edit]
(C++20)
 vergleicht lexikographisch die Werte zweier stacks
(function template) [edit]
(C++20)
 vergleicht die zugrundeliegenden Iteratoren
(Funktionstemplate) [edit]
(C++11)(C++11)(entfernt in C++20)(C++11)(C++11)(C++11)(C++11)(C++20)
 vergleicht die zugrundeliegenden Iteratoren
(Funktionstemplate) [edit]
(in C++20 entfernt)
 vergleicht zwei istream_iterators
(function template) [bearbeiten]
(in C++20 entfernt)
 vergleicht zwei istreambuf_iterators
(function template) [bearbeiten]
(in C++20 entfernt)
 vergleicht zwei komplexe Zahlen oder eine komplexe Zahl und einen Skalar
(function template) [edit]
 vergleicht zwei Valarrays oder ein Valarray mit einem Wert
(function template) [edit]
(C++11)(C++11)(entfernt in C++20)
 vergleicht die internen Zustände zweier Pseudozufallszahlengeneratoren
(function) [bearbeiten]
(C++11)(C++11)(entfernt in C++20)
 vergleicht zwei Verteilungsobjekte
(function) [bearbeiten]
(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(C++20)
 vergleicht ein sub_match mit einem anderen sub_match, einem String oder einem Zeichen
(Funktionstemplate) [bearbeiten]
(in C++20 entfernt)
 vergleicht lexikographisch die Werte in den beiden Übereinstimmungsergebnissen
(Funktionstemplate) [bearbeiten]
(in C++20 entfernt)
 vergleicht zwei regex_iterators
(public member function of std::regex_iterator<BidirIt,CharT,Traits>) [bearbeiten]
(in C++20 entfernt)
 vergleicht zwei regex_token_iterators
(public member function of std::regex_token_iterator<BidirIt,CharT,Traits>) [bearbeiten]
(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(C++20)
 vergleicht zwei thread::id Objekte
(Funktion) [edit]

Der Namespace std::rel_ops bietet generische Operatoren !=, >, <= und >=

Definiert in der Header-Datei <utility>
Definiert im Namensraum std::rel_ops
(veraltet in C++20)
 generiert automatisch Vergleichsoperatoren basierend auf benutzerdefinierten operator== und operator<
(Funktionsvorlage) [edit]

[bearbeiten] Fehlerberichte

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

DR angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
CWG 583
(N3624)		 C++98 Alle sechs Vergleichsoperatoren konnten verwendet werden, um
einen Zeiger mit einer Nullzeigerkonstante zu vergleichen		 nur Gleichheitsoperatoren
sind erlaubt
CWG 661 C++98 Die tatsächliche Semantik von arithmetischen Vergleichen (z. B.
ob 1 < 2 wahr oder falsch ergibt) war nicht spezifiziert		 Spezifikation hinzugefügt
CWG 879 C++98 Zeiger auf Funktionstypen und Zeiger
auf void hatten keine integrierten Vergleiche		 hinzugefügt Vergleich
Spezifikation für diese Zeiger
CWG 1596 C++98 Nicht-Array-Objekte wurden für den Zweck der Zeigerarithmetik als zu Arrays mit
einem Element gehörig betrachtet		 die Regel wird auch
auf den Vergleich angewendet
CWG 1598 C++98 Zwei Zeiger auf Member von Klassen, die unterschiedlich sind und
keine Basisklasse der anderen ist, verglichen nicht gleich
auch wenn die Offsets der referenzierten Member gleich sein können		 das Ergebnis ist
nicht spezifiziert
in diesem Fall
CWG 1858 C++98 Es war unklar, ob zwei Zeiger auf Member
die auf unterschiedliche Member derselben Union verweisen
gleich verglichen werden, als ob sie auf dasselbe Member verweisen		 sie vergleichen
gleich in diesem Fall
CWG 2419 C++98 Ein Zeiger auf ein Nicht-Array-Objekt wurde nur als
Zeiger auf das erste Element eines Arrays der Größe 1 behandelt
im Zeigervergleich, wenn der Zeiger durch & erhalten wurde		 gilt für alle Zeiger
auf Nicht-Array-Objekte
CWG 2526 C++98 Die Definition von relationalen Vergleichen (>, >=, < und <=) von
Zeigern auf void und Funktionszeiger wurde durch N3624 entfernt		 wiederhergestellt
CWG 2796 C++17 Funktionszeigerkonvertierungen wurden nicht auf den konvertierten
Zeigeroperanden bei integrierten Zeiger-Relationsvergleichen durchgeführt		 führt diese
Konvertierungen in diesem Fall durch

[bearbeiten] Siehe auch

Häufige Operatoren
Zuweisung Inkrement
Dekrement 		Arithmetik Logisch Vergleich Member
Zugriff 		Sonstiges

a = b
a += b
a -= b
a *= b
a /= b
a %= b
a &= b
a |= b
a ^= b
a <<= b
a >>= b

++a
--a
a++
a--

+a
-a
a + b
a - b
a * b
a / b
a % b
~a
a & b
a | b
a ^ b
a << b
a >> b

!a
a && b
a || b

a == b
a != b
a < b
a > b
a <= b
a >= b
a <=> b

a[...]
*a
&a
a->b
a.b
a->*b
a.*b

Funktionsaufruf

a(...)
Komma

a, b
Ternär

a ? b : c
Spezielle Operatoren

static_cast konvertiert einen Typ in einen anderen verwandten Typ
dynamic_cast konvertiert innerhalb von Vererbungshierarchien
const_cast fügt cv-Qualifizierer hinzu oder entfernt sie
reinterpret_cast konvertiert einen Typ in einen nicht verwandten Typ
C-Stil Cast konvertiert einen Typ in einen anderen durch eine Mischung aus static_cast, const_cast und reinterpret_cast
new erstellt Objekte mit dynamischer Speicherverwaltung
delete zerstört zuvor mit new-Ausdruck erstellte Objekte und gibt den zugewiesenen Speicherbereich frei
sizeof fragt die Größe eines Typs ab
sizeof... fragt die Größe eines packs ab (seit C++11)
typeid fragt die Typinformationen eines Typs ab
noexcept prüft, ob ein Ausdruck eine Ausnahme auslösen kann (seit C++11)
alignof fragt die Ausrichtungsvoraussetzungen eines Typs ab (seit C++11)

C-Dokumentation für Vergleichsoperatoren
Abgerufen von "https://cppreference.de/mwiki/index.php?title=cpp/language/operator_comparison&oldid=177936"