Logisch NOT !

Der Logisch-NOT-Operator wandelt einen boolschen Wert in sein Gegenteil um: Aus false wird true und umgekehrt.

x is false

#include <stdio.h>

int main(){
  int x = 0;
  if( x){printf("x is true\n");}
  if(!x){printf("x is false\n");}
  return 0;
}

Siehe auch bool-Typ, Bitweise-NOT-Operator ~, Logisch-AND-Operator &&, Logisch-OR-Operator ||

Details

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

Der Operator ist zulässig für boolsche Werte, Integer-Werte, Fliesskommawerte sowie Pointer. Zwar ist dieser Operator bereits in C verfügbar, jedoch sind der Typ bool sowie die Wahrheitswerte true und false erst ab C++ verfügbar. In C wird für den Wert false der Integer-Wert 0, für true ein Integer-Wert ungleich 0 (normalerweise 1) verwendet.

Der Rückgabewert des Operators kann nur entweder true oder false (oder die entsprechenden Integer-Werte in C) sein. Im Gegensatz dazu gibt der Bitweise-NOT-Operator stets einen Integer-Wert zurück.

Der Unterschied zwischen der logischen und der bitweisen Variante des NOT-Operators ist für Einsteiger in die Sprache manchmal schwer verständlich. Der Unterschied ist: Die logische Variante verändert 1-Bit-Werte, die bitweise Variante verändert alle Bits von Werten. Selbst bei erfahrenen Programmierern kommt es vor, dass man aufgrund der ähnlichen Schreibweise (! oder ~) aus Versehen und ohne es zu merken den falschen Operatoren verwendet. Da zudem in gewissen Fällen (beispielsweise bei der Anwendung des Operators auf den Wert -1) die beiden Operatoren dieselben Ergebnisse liefern, ist dies eine schwer aufzufindende Fehlerquelle, die manchmal einige Stunden Fehlersuche benötigt.

Überladen des Operators

Der Logisch-NOT-Operator hat grundsätzlich die semantische Bedeutung einer boolschen Verneinung. Die Überladung des Operators wird auch häufig verwendet, wenn allgemein über zwei Zustände eines Objektes entschieden werden soll. Allerdings ist auch jegliche andere Semantik vom Programmierer definierbar. Trotzdem sei angemerkt, dass der Logisch-NOT-Operator selten überladen wird, insbesondere, da oftmals anstelle der expliziten Ausprogrammierung eines logischen Vergleiches ein Casting-Operator nach bool überladen wird, worauf mit dem eingebauten Logisch-NOT-Operator weiterprogrammiert werden kann.

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

inside class


outside class

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

Type operator !(Type);

Im folgenden Beispiel wird eine Klasse präsentiert für eine 2x2 Matrix. Der überladene Logisch-NOT-Operator gibt hier die Transposition der Matrix zurück.

1.000000, 2.000000
3.000000, 4.000000

1.000000, 3.000000
2.000000, 4.000000

#include <cstdio>

class Matrix22{
  float a[4];
public:
  Matrix22(float d1, float d2, float d3, float d4){
    a[0]=d1; a[1]=d2; a[2]=d3; a[3]=d4;
  }
  void print(){
    printf("%f, %f\n%f, %f\n", a[0], a[1], a[2], a[3]);
  }
  
  Matrix22 operator !() const {
    return Matrix22(a[0], a[2], a[1], a[3]);
  }
};

int main(){
  Matrix22 m1(1, 2, 3, 4);
    m1 .print();
  (!m1).print();
  return 0;
}