Logisch OR ||

Der Logisch-OR-Operator verknüpft zwei boolsche Werte nach den Regeln des logischen OR: false OR false ergibt false und alle anderen Kombinationen ergeben true.

x OR y is true

#include <stdio.h>

int main(){
  int x = 0;
  int y = 1;
  if(x || y){printf("x OR y is true\n");}
  return 0;
}

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

Details

Der Logisch-OR-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.

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-OR-Operator stets einen Integer-Wert zurück.

Der Unterschied zwischen der logischen und der bitweisen Variante des OR-Operators ist für Einsteiger in die Sprache manchmal schwer verständlich. Der Unterschied ist: Die logische Variante verknüpft 1-Bit Werte, die bitweise Variante verknüpft mehrere 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 die beiden Operatoren dieselben Ergebnisse liefern, ist dies eine schwer aufzufindende Fehlerquelle, die manchmal einige Stunden Fehlersuche benötigt.

Überladen des Operators

Der Logisch-OR-Operator hat grundsätzlich die semantische Bedeutung einer boolschen OR-Verknüpfung. Allerdings ist auch jegliche andere Semantik vom Programmierer definierbar. Trotzdem sei angemerkt, dass der Logisch-OR-Operator sehr 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-OR-Operator weiterprogrammiert werden kann.

Die Prototypen für das Überladen des Logisch-OR-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 je eine Klasse für einen Punkt und eine Linie in der zweidimensionalen Ebene präsentiert. Der überladene Logisch-OR-Operator gibt Antwort auf die Frage, ob Linien parallel zueinander liegen. Es sei angemerkt, dass die hier vorliergende Ausprogrammierung nur illustrativen Charakter hat und numerisch keinesfalls stabil ist.

l1 and l2 are parallel.
l1 and l3 are parallel.

#include <cstdio>
#include <cmath>

class Point{
public:
  float x, y;
  Point(float newx, float newy) : x(newx), y(newy){}
};

class Line{
  Point a, b;
public:
  Line(const Point& p1, const Point& p2) : a(p1), b(p2){}
  
  bool operator ||(const Line& l2) const{
    float dx = fabs(b.x - a.x) - fabs(l2.b.x - l2.a.x);
    float dy = fabs(b.y - a.y) - fabs(l2.b.y - l2.a.y);
    return !dx && !dy;
  }
};

int main(){
  Point p1(1, 2);
  Point p2(3, 4);
  Point p3(5, 6);
  Point p4(5, 5);
  Line l1(p1, p2);
  Line l2(p2, p3);
  Line l3(p3, p2);
  Line l4(p1, p4);
  if(l1 || l2){printf("l1 and l2 are parallel.\n");}
  if(l1 || l3){printf("l1 and l3 are parallel.\n");}
  if(l1 || l4){printf("l1 and l4 are parallel.\n");}
  return 0;
}