Comparison operators

Vergleichsoperatoren sind binäre Operatoren, die eine Bedingung prüfen und 1 zurückgeben, wenn diese Bedingung logisch true ist, und 0 , wenn diese Bedingung false ist.

Relationale Operatoren

Die relationalen Operatorausdrücke haben die Form

Der Typ jedes relationalen Operatorausdrucks ist int , und sein Wert (der kein Lvalue ist) ist 1 , wenn die spezifizierte Beziehung zutrifft, und ​ 0 ​ , wenn die spezifizierte Beziehung nicht zutrifft.

Wenn lhs und rhs Ausdrücke eines beliebigen Realtyps sind, dann

• usual arithmetic conversions werden durchgeführt
• die Werte der Operanden nach der Konvertierung werden im üblichen mathematischen Sinne verglichen (mit der Ausnahme, dass positive und negative Nullen als gleich betrachtet werden und jeder Vergleich mit einem NaN-Wert null zurückgibt)

Beachten Sie, dass komplexe und imaginäre Zahlen nicht mit diesen Operatoren verglichen werden können.

Wenn lhs und rhs Ausdrücke vom Zeigertyp sind, müssen beide Zeiger auf Objekte kompatibler Typen sein, wobei Qualifizierer der referenzierten Objekte ignoriert werden.

• ein Zeiger auf ein Objekt, das kein Element eines Arrays ist, wird so behandelt, als würde er auf ein Element eines Arrays mit einem Element zeigen
• wenn zwei Zeiger auf dasselbe Objekt zeigen oder beide auf das Element nach dem Ende desselben Arrays zeigen, sind sie im Vergleich gleich
• wenn zwei Zeiger auf verschiedene Elemente desselben Arrays zeigen, ist derjenige größer, der auf das Element mit dem größeren Index zeigt
• wenn ein Zeiger auf ein Element eines Arrays zeigt und der andere Zeiger auf das Element nach dem Ende desselben Arrays zeigt, ist der Zeiger auf das Element nach dem Ende größer
• wenn die beiden Zeiger auf Mitglieder derselben struct zeigen, ist der Zeiger auf das später in der Struct-Definition deklarierte Mitglied größer als der Zeiger auf das früher deklarierte Mitglied
• Zeiger auf Mitglieder derselben Union sind im Vergleich gleich
• alle anderen Zeigervergleiche rufen undefiniertes Verhalten hervor

#include <assert.h>
int main(void)
{
    assert(1 < 2);
    assert(2+2 <= 4.0); // int konvertiert zu double, zwei 4.0-Werte vergleichen gleich
    struct { int x,y; } s;
    assert(&s.x < &s.y); // Struct-Member werden in Deklarationsreihenfolge verglichen
    double d = 0.0/0.0; // NaN
    assert( !(d < d) );
    assert( !(d > d) );
    assert( !(d <= d) );
    assert( !(d >= d) );
    assert( !(d == d) );
    float f = 0.1; // f = 0.100000001490116119384765625
    double g = 0.1; // g = 0.1000000000000000055511151231257827021181583404541015625
    assert(f > g); // unterschiedliche Werte
}

Gleichheitsoperatoren

Die Gleichheitsoperator-Ausdrücke haben die Form

Der Typ eines jeden Gleichheitsoperator-Ausdrucks ist int , und sein Wert (der kein Lvalue ist) ist 1 , wenn die spezifizierte Beziehung zutrifft, und ​ 0 ​ , wenn die spezifizierte Beziehung nicht zutrifft.

• wenn beide Operanden arithmetische Typen haben, übliche arithmetische Konvertierungen durchgeführt werden und die resultierenden Werte im üblichen mathematischen Sinne verglichen werden (mit der Ausnahme, dass positive und negative Nullen als gleich betrachtet werden und jeder Vergleich, der einen NaN-Wert beinhaltet, einschließlich des Gleichheitsvergleichs mit sich selbst, Null zurückgibt). Insbesondere sind Werte komplexen Typs gleich, wenn ihre Realteile als gleich verglichen werden und ihre Imaginärteile als gleich verglichen werden.

• wenn ein Operand ein Zeiger ist und der andere ein Nullzeiger-Konstant, wird der Nullzeiger-Konstant zuerst konvertiert in den Typ des Zeigers (was einen Nullzeiger-Wert ergibt), und die beiden Zeiger werden wie unten beschrieben verglichen
• wenn ein Operand ein Zeiger ist und der andere ein Zeiger auf void, wird der nicht-void Zeiger konvertiert in den Zeiger auf void und die beiden Zeiger werden wie unten beschrieben verglichen
• zwei Zeiger vergleichen gleich, wenn eine der folgenden Bedingungen zutrifft:

• sie sind beide Nullzeigerwerte ihres Typs
• sie zeigen beide auf dasselbe Objekt oder dieselbe Funktion
• ein Zeiger zeigt auf ein Struct/Union/Array-Objekt und der andere auf sein erstes Mitglied/jedes Mitglied/erstes Element
• sie zeigen beide auf das Element nach dem letzten Element desselben Arrays
• einer zeigt auf das Element nach dem Ende eines Arrays und der andere auf den Anfang eines anderen Arrays (desselben Typs), das dem ersten in einem größeren Array oder in einem Struct ohne Padding folgt

(wie bei relationalen Operatoren verhalten sich Zeiger auf Objekte, die keine Elemente eines Arrays sind, wie Zeiger auf Elemente von Arrays der Größe 1)

Hinweise

Objekte vom Strukturtyp werden nicht automatisch als gleich verglichen, und der Vergleich mit memcmp ist nicht zuverlässig, da die Padding-Bytes beliebige Werte haben können.

Da Zeigervergleiche mit Zeigern auf void funktionieren, kann das Makro NULL in C als ( void * ) 0 definiert werden, obwohl dies in C++ ungültig wäre, da void-Zeiger sich dort nicht implizit in typisierte Zeiger umwandeln lassen.

Bei Gleitkommawertvergleichen auf Gleichheit ist Vorsicht geboten, da die Ergebnisse vieler Operationen nicht exakt dargestellt werden können und gerundet werden müssen. In der Praxis werden Gleitkommazahlen normalerweise mit einer Toleranz von einer oder mehreren Einheiten der letzten Stelle verglichen.

#include <assert.h>
int main(void)
{
    assert(2+2 == 4.0); // int konvertiert zu double, zwei 4.0-Werte vergleichen gleich
    int n[2][3] = {1,2,3,4,5,6};
    int* p1 = &n[0][2]; // letztes Element in der ersten Zeile
    int* p2 = &n[1][0]; // Anfang der zweiten Zeile
    assert(p1+1 == p2); // vergleichen gleich
    double d = 0.0/0.0; // NaN
    assert( d != d ); // NaN ist nicht gleich sich selbst
    float f = 0.1; // f = 0.100000001490116119384765625
    double g = 0.1; // g = 0.1000000000000000055511151231257827021181583404541015625
    assert(f != g); // unterschiedliche Werte
}

Referenzen

Siehe auch

Operator-Präzedenz