Namensräume
Varianten
Aktionen

Vergleichsoperatoren

Von cppreference.com
< c‎ | Sprache
 
C
 
C-Sprache
 
Ausdrücke
 

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

Operator Operatorname Beispiel Beschreibung
== gleich a == b a ist gleich b
!= ungleich a != b a ist ungleich b
< kleiner als a < b a ist kleiner als b
> größer als a > b a ist größer als b
<= kleiner als oder gleich a <= b a ist kleiner als oder gleich b
>= größer als oder gleich a >= b a ist größer als oder gleich b

Inhalt

[bearbeiten] Relationale Operatoren

Die Ausdrücke mit relationalen Operatoren haben die Form

lhs < rhs (1)
lhs > rhs (2)
lhs <= rhs (3)
lhs >= rhs (4)
1) Kleiner-als-Ausdruck
2) Größer-als-Ausdruck
3) Kleiner-gleich-Ausdruck
4) Größer-gleich-Ausdruck

wobei

lhs, rhs - Ausdrücke, die beide einen realen Typ oder beide einen Zeigertyp auf ein Objekt haben

Der Typ jedes Ausdrucks mit einem relationalen Operator ist int, und sein Wert (der kein lvalue ist) ist 1, wenn die angegebene Beziehung wahr ist, und ​0​, wenn die angegebene Beziehung nicht wahr ist.

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

  • übliche arithmetische Umwandlungen werden durchgeführt
  • die Werte der Operanden nach der Umwandlung werden im üblichen mathematischen Sinne verglichen (außer dass positive und negative Nullen gleich sind und jeder Vergleich, der einen NaN-Wert beinhaltet, Null zurückgibt)

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

Wenn lhs und rhs Ausdrücke vom Zeigertyp sind, müssen sie beide Zeiger auf Objekte von kompatiblen Typen sein, wobei Qualifizierer der zeigenden 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 Ende desselben Arrays zeigen, vergleichen sie sich als gleich
  • wenn zwei Zeiger auf verschiedene Elemente desselben Arrays zeigen, vergleicht sich der Zeiger, der auf das Element mit dem größeren Index zeigt, als größer.
  • wenn ein Zeiger auf ein Element eines Arrays zeigt und der andere Zeiger auf das Ende desselben Arrays zeigt, vergleicht sich der Zeiger, der auf das Ende zeigt, als größer
  • wenn die beiden Zeiger auf Mitglieder derselben Struktur zeigen, vergleicht sich der Zeiger auf das später in der Strukturdefinition deklarierte Mitglied als größer als der Zeiger auf das früher deklarierte Mitglied.
  • Zeiger auf Mitglieder derselben Union vergleichen sich als gleich
  • alle anderen Zeigervergleiche führen zu undefiniertem Verhalten
Führen Sie diesen Code aus
#include <assert.h>
int main(void)
{
    assert(1 < 2);
    assert(2+2 <= 4.0); // int converts to double, two 4.0's compare equal
 
    struct { int x,y; } s;
    assert(&s.x < &s.y); // struct members compare in order of declaration
 
    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); // different values
}

[bearbeiten] Gleichheitsoperatoren

Die Ausdrücke mit Gleichheitsoperatoren haben die Form

lhs == rhs (1)
lhs != rhs (2)
1) Gleichheitsausdruck
2) Ungleichheitsausdruck

wobei

lhs, rhs - Ausdrücke, die
  • beide vom Typ nullptr_t sind
  • einer vom Typ nullptr_t ist und der andere eine Nullzeigerkonstante ist
 (seit C23)
  • beide Zeiger auf Objekte oder Funktionen von kompatiblen Typen sind, wobei Qualifizierer der zeigenden Typen ignoriert werden
  • einer ein Zeiger auf ein Objekt und der andere ein Zeiger auf void (möglicherweise qualifiziert) ist
  • einer ein Zeiger auf ein Objekt oder eine Funktion und der andere eine Nullzeigerkonstante wie NULL oder nullptr(seit C23) ist

Der Typ jedes Ausdrucks mit einem Gleichheitsoperator ist int, und sein Wert (der kein lvalue ist) ist 1, wenn die angegebene Beziehung wahr ist, und ​0​, wenn die angegebene Beziehung nicht wahr ist.

  • Wenn beide Operanden arithmetische Typen haben, werden übliche arithmetische Umwandlungen durchgeführt und die resultierenden Werte im üblichen mathematischen Sinne verglichen (außer dass positive und negative Nullen gleich sind und jeder Vergleich, der einen NaN-Wert beinhaltet, einschließlich Gleichheit mit sich selbst, Null zurückgibt). Insbesondere sind Werte vom komplexen Typ gleich, wenn ihre Realteile gleich sind und ihre Imaginärteile gleich sind.
  • zwei nullptr_t-Werte oder ein nullptr_t-Wert und eine Nullzeigerkonstante vergleichen sich als gleich
 (seit C23)
  • wenn ein Operand ein Zeiger ist und der andere eine Nullzeigerkonstante ist, wird die Nullzeigerkonstante zuerst in den Typ des Zeigers umgewandelt (was einen Nullzeigerwert ergibt) und die beiden Zeiger werden wie unten beschrieben verglichen
  • wenn ein Operand ein Zeiger ist und der andere ein Zeiger auf void ist, wird der Nicht-Void-Zeiger in den Zeiger auf void umgewandelt und die beiden Zeiger werden wie unten beschrieben verglichen
  • zwei Zeiger vergleichen sich als gleich, wenn eine der folgenden Bedingungen zutrifft
  • sie sind beide Nullzeigerwerte ihres Typs
  • sie sind beide Zeiger auf dasselbe Objekt oder dieselbe Funktion
  • ein Zeiger ist auf ein Struktur-/Union-/Array-Objekt und der andere auf dessen erstes Mitglied/irgendein Mitglied/erstes Element
  • sie zeigen beide auf das Element nach dem letzten Element desselben Arrays
  • einer zeigt auf das Ende eines Arrays und der andere auf den Anfang eines anderen Arrays (desselben Typs), das dem ersten in einem größeren Array oder in einer Struktur ohne Auffüllung folgt

(wie bei relationalen Operatoren verhalten sich Zeiger auf Objekte, die nicht zu einem Array gehören, wie Zeiger auf Elemente von Arrays der Größe 1)

[bearbeiten] Hinweise

Objekte vom Strukturtyp vergleichen sich nicht automatisch als gleich, und ihr Vergleich mit memcmp ist nicht zuverlässig, da die Auffüllbytes beliebige Werte haben können.

Da der Zeigervergleich mit Zeigern auf void funktioniert, kann das Makro NULL in C als (void*)0 definiert sein, obwohl dies in C++ ungültig wäre, wo void-Zeiger nicht implizit in typisierte Zeiger umgewandelt werden.

Beim Vergleichen von Gleitkommawerten 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 verglichen, wobei die Differenz von einer oder mehreren Stellen der letzten Stelle zugelassen wird.

Führen Sie diesen Code aus
#include <assert.h>
int main(void)
{
    assert(2+2 == 4.0); // int converts to double, two 4.0's compare equal
 
    int n[2][3] = {1,2,3,4,5,6};
    int* p1 = &n[0][2]; // last element in the first row
    int* p2 = &n[1][0]; // start of second row
    assert(p1+1 == p2); // compare equal
 
    double d = 0.0/0.0; // NaN
    assert( d != d ); // NaN does not equal itself
 
    float f = 0.1; // f = 0.100000001490116119384765625
    double g = 0.1; // g = 0.1000000000000000055511151231257827021181583404541015625
    assert(f != g); // different values
}

[bearbeiten] Referenzen

  • C17-Standard (ISO/IEC 9899:2018)
  • 6.5.8 Relationale Operatoren (S. 68-69)
  • 6.5.9 Gleichheitsoperatoren (S. 69-70)
  • C11-Standard (ISO/IEC 9899:2011)
  • 6.5.8 Relationale Operatoren (S. 95-96)
  • 6.5.9 Gleichheitsoperatoren (S. 96-97)
  • C99-Standard (ISO/IEC 9899:1999)
  • 6.5.8 Relationale Operatoren (S. 85-86)
  • 6.5.9 Gleichheitsoperatoren (S. 86-87)
  • C89/C90-Standard (ISO/IEC 9899:1990)
  • 3.3.8 Relationale Operatoren
  • 3.3.9 Gleichheitsoperatoren

[bearbeiten] Siehe auch

Operatorrangfolge

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->b
a.b

a(...)
a, b
(type) a
a ? b : c
sizeof

_Alignof
(seit C11)
(bis C23)

alignof
(seit C23)

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