Comparison operators – cppreference.com

Original:

Compares the arguments.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Original:

Returns the boolean result of comparison of the values of the arguments, which are not modified.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Original:

For every pair of promoted arithmetic types L and R, including enumeration types, the following function signatures participate in overload resolution:

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Original:

If the operands has arithmetic or enumeration type (scoped or unscoped), usual arithmetic conversions are performed following the rules for arithmetischen Operatoren. The values are compared after conversions:

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

#include <iostream>
int main()
{
    std::cout << std::boolalpha;
    int n = -1;

    int n2 = 1;
    std::cout << " -1 == 1? " << (n == n2) << '\n'
              << "Comparing two signed values:\n"
              << " -1  < 1? " << (n < n2) << '\n'
              << " -1  > 1? " << (n > n2) << '\n';

    unsigned int u = 1;
    std::cout << "Comparing signed and unsigned:\n"
              << " -1  < 1? " << (n < u) << '\n'
              << " -1  > 1? " << (n > u) << '\n';

    unsigned char uc = 1;
    std::cout << "Comparing signed and smaller unsigned:\n"
              << " -1  < 1? " << (n < uc) << '\n'
              << " -1  > 1? " << (n > uc) << '\n';
}

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

Original:

For every type P which is either pointer to object or pointer to function or std::nullptr_t, and for every type MP that is a pointer to member object or pointer to member function, the following function signatures participate in overload resolution:

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Original:

Comparison operators can be used to compare two pointers (or pointers-to-members, for operator== and operator!= only), or a pointer and a null pointer constant, or two null pointer constants (but only as long as at least one of them is std::nullptr_t: comparison of NULL and NULL follows arithmetic comparison rules). Pointer Konvertierungen (pointer to member conversions if the arguments are pointers to members) and Qualifikation Konvertierungen are applied to both operands to obtain the composite pointer type, as follows

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Wenn beide Operanden NULL-Zeiger-Konstanten sind, ist der Verbund Zeigertyp std::nullptr_t

Wenn ein Operand ein Null-Zeiger Konstante und das andere ist ein Zeiger, der zusammengesetzten Typ genau die Zeiger-Typ

Wenn beide Operanden Zeiger auf die gleiche Art, mit verschiedenen cv-Qualifikation sind, ist der Verbund Zeiger auf die gleiche Art mit cv-Qualifikation, die eine Vereinigung der cv-Qualifikationen der Argumente ist .

Beachten Sie, dass dies bedeutet, dass jeder Zeiger mit void* verglichen werden können .

Original:

Results of comparing two pointers (after conversions) are determined as follows:

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Wenn die Zeiger p und q

verweisen auf das gleiche Objekt oder Funktion

oder weisen ein über das Ende des gleichen Array

oder sind beide null Zeiger

dann die Zeiger sind gleich: p==q, p<=q und p>=q Rückkehr true, während p!=q, p<q und p>q Rückkehr false

Wenn einer der Operanden ein Null-Zeiger und die andere nicht, sie ungleich vergleichen: p==q kehrt true, p!=q kehrt false, ist das Verhalten anderer Betreiber nicht näher .

Wenn die Zeiger p und q Punkt an Mitglieder der gleichen Array a[i] und a[j] oder ein über das Ende des Arrays, ergibt sie des Vergleichens der Zeiger ist der gleiche wie das Ergebnis des Vergleichs der Indizes: wenn i<j==true dann {{{1}}} .

Wenn die Zeiger p und q Punkt nicht-statische Datenelemente innerhalb der gleichen Klasse oder anderen Basis Unterobjekte innerhalb derselben abgeleitete Klasse, oder an ihre Mitglieder oder Unterobjekte rekursiv, und wenn die spitzen-to members / Unterobjekte haben die gleiche Zutrittskontrolle (zB sowohl public:), und die Klasse ist nicht eine Vereinigung, dann der Zeiger auf die später erklärte Unterobjekt / Mitglied im Vergleich größer als der Zeiger auf die bereits deklarierte Unterobjekt / Mitglied. In anderen Worten, die Mitglieder in jeder der drei Zugriffsarten im Speicher in der Reihenfolge der Deklaration positioniert .

Wenn die Zeiger p und q Punkt Mitglieder derselben union, diese gleich Vergleichen (typischerweise eine explizite Konvertierung in void* wird für einen der Operanden benötigt)

Wenn einer der Zeiger ist ein Zeiger auf void und beide Zeiger auf der gleichen Adresse oder beiden Null-Pointer, vergleichen sie gleich .

Wenn zwei Null-Zeiger-Konstanten verglichen werden, vergleichen sie gleich .

Wenn beide Operanden Zeigern auf Elementfunktionen (Objekt oder eine Funktion) sind, vergleichen sie gleich, wenn sie beide auf dem gleichen Mitglied der meisten abgeleiteten Klasse .

Andernfalls (wenn die Zeiger auf Objekte in unterschiedlichen Arrays, oder um verschiedene Funktionen, oder den Mitgliedern der einen Gegenstand mit unterschiedlichen Zugangskontrolle, usw. zeigen), die Ergebnisse der p<q, p>q, p<=q und p>=q sind nicht spezifiziert, und kehrt p!=q false.

#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: p1 == p2 " << (p1 == p2)
              << ", p1 < p2 "  << (p1 < p2) << '\n';

    Foo f;
    int* p3 = &f.n1;
    int* p4 = &f.n2;
    std::cout << "Pointers to members of a class: p3 == p4 " << (p3 == p4)
              << ", p3 < p4 "  << (p3 < p4) << '\n';

    Union u;
    int* p5 = &u.n;
    double* p6 = &u.d;
    std::cout << "Pointers to members of a union: p5 == (void*)p6 " << (p5 == (void*)p6)
              << ", p5 < 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 < p6 false

Original:

Because these operators group left-to-right, the expression a<b<c is parsed (a<b)<c, and not a<(b<c) or (a<b)&&(b<c).

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Original:

A common requirement for user-defined operator< is strenge schwache Ordnung. In particular, this is required by the standard algorithms and containers that work with LessThanComparable types: std::sort, std::max_element, std::map, etc.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Original:

Although the results of comparing pointers of random origin (e.g. not all pointing to members of the same array) is unspecified, many implementations provide strenge totale Ordnung of pointers, e.g. if they are implemented as addresses within continuous virtual address space. Those implementations that do not (e.g. where not all bits of the pointer are part of a memory address and have to be ignored for comparison, or an additional calculation is required or otherwise pointer and integer is not a 1 to 1 relationship), provide a specialization of std::less for pointers that has that guarantee. This makes it possible to use all pointers of random origin as keys in standard associative containers such as std::set or std::map.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Original:

Comparison operators are overloaded for many classes in the standard library.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.