Ungleich !=

Der Ungleichheits-Operator führt einen Vergleich zweier Operanden aus. Wenn sich die beiden Operanden unterscheiden, so gibt der Operator den boolschen Wert true zurück, ansonsten false. In C wird anstelle von true der Wert 1 und anstelle von false der Wert 0 zurückgegeben. Der Ungleichheits-Operator wird sehr häufig für Bedingungen in Kontrollstrukturen verwendet.

a is unequal b

#include <stdio.h>

int main(){
  int a = 10;
  int b = 11;
  if(a != b){printf("a is unequal b\n");}
  return 0;
}

Siehe auch Gleich-Operator ==, Logik

Details

Der Ungleichheits-Operator erwartet zwei Operanden als rvalues und wird von links nach rechts abgearbeitet. Der Rückgabewert ist ein rvalue, in C ein Integer-Typ, in C++ ein boolscher Typ.

Handelt es sich bei den Typen der beiden Operanden um arithmetische Typen, so werden die Werte arithmetisch miteinander verglichen. Gegebenfalls wird eine automatische arithmetische Umwandlung vorgenommen.

Handelt es sich bei den Typen der beiden Operanden um Pointer-Typen, so wird nach den Regeln der Pointer-Arithmetik vorgegangen.

Der Operator ist zulässig für arithmetische (Integer- und Fliesskomma-) Typen, boolsche Typen sowie Pointer.

Handelt es sich bei beiden Typen der beiden Operanden um einen boolschen Typ, so entspricht das Resultat einer XOR-Verknüpfung der beiden Wahrheitswerte.

Entsprechen die Typen keinen der genannten Typen, so wird ein implizites Casting vorgenommen, welches gegebenfalls zu Compiler-Fehlern oder Warnungen führen kann. Warnungen sowohl von der Pointer-Arithmetik, der arithmetischen Umwandlung, als auch von impliziten Castings können mittels explizitem Casting unterdrückt werden.

Überladen des Operators

Der Ungleichheits-Operator hat grundsätzlich die semantische Bedeutung eines Ungleichheits-Tests zweier Operanden. Dem Programmierer steht jedoch frei, eine andere Semantik zu definieren.

Die Prototypen für das Überladen des Ungleichheits-Operators sind die folgenden (Einschränkungen und Erläuterungen siehe Überladen von Operatoren):

inside class


outside class

Type operator !=(Type);
Type operator !=(Type) const;

Type operator !=(Type, Type);

Im folgenden Beispiel wird eine Klasse präsentiert für einen zweidimensionalen Vektor. Die Überladung des Ungleichheits-Operators überprüft, ob die Vektorfelder sich mindestens an einer Stelle unterscheiden.

v1 and v3 are not equal.

#include <cstdio>

class Vector2{
  float a[2];
public:
  Vector2(float x, float y){a[0]=x; a[1]=y;}
  
  bool operator !=(Vector2& v2) const {
    return (a[0] != v2.a[0]) || (a[1] != v2.a[1]);
  }
};

int main(){
  Vector2 v1(10, 20);
  Vector2 v2(10, 20);
  Vector2 v3(10, 21);
  if(v1 != v2){printf("v1 and v2 are not equal.\n");}
  if(v1 != v3){printf("v1 and v3 are not equal.\n");}
  return 0;
}