Bitweise OR |

Der Bitweise-OR-Operator verknüpft alle Bits zweier Integer-Werte nach den Regeln des logischen OR: 0 OR 0 ergibt 0 und alle anderen Kombinationen ergeben 1.

01001001100101100000001011010010
00111010110111100110100010110001
01111011110111100110101011110011

#include <stdio.h>

void printbinary(int x){
  char str[33]; str[32] = '\0';
  int i = 32;
  while(i){i--; str[i] = (x & 1) + '0'; x>>=1;}
  printf("%s\n", str);
}

int main(){
  int x = 1234567890;
  int y = 987654321;
  printbinary(x);
  printbinary(y);
  printbinary(x | y);
  return 0;
}

Siehe auch Logisch-OR-Operator ||, Zuweisung |=, Bitweise-NOT-Operator ~, Bitweise-AND-Operator &, Bitweise-XOR-Operator ^

Details

Der Bitweise-OR-Operator erwartet zwei Operanden als rvalues und wird von links nach rechts abgearbeitet. Der Rückgabewert ist ein rvalue, der stets ein Integer-Typ ist.

Der Bitweise-OR-Operator ist nur für Integer-Werte zulässig. Unter C++ ist zusätzlich auch die Anwendung des Operators auf boolsche Werte erlaubt, welche jedoch vor Anwendung des Operators in einen int umgewandelt werden.

Der Unterschied zwischen der bitweisen und der logischen Variante des OR-Operators ist für Einsteiger in die Sprache manchmal schwer verständlich. Der Unterschied ist: Die bitweise Variante verknüpft mehrere Bits von Werten, die logische Variante verknüpft 1-Bit-Werte. 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.

Der Bitweise-OR-Operator wird häufig für Masken verwendet.

Überladen des Operators

Der Bitweise-OR-Operator hat grundsätzlich die semantische Bedeutung einer komponentenweisen boolschen OR-Verknüpfung. Allerdings ist auch jegliche andere Semantik vom Programmierer definierbar. Trotzdem sei angemerkt, dass der Bitweise-OR-Operator eher selten überladen wird.

Die Prototypen für das Überladen des Bitweise-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 eine Klasse für einen Bitstring mit 10 Zeichen präsentiert. Der überladene Bitweise-OR-Operator berechnet den entsprechenden Bitstring für eine OR-Verknüpfung.

1101111011

#include <cstdio>
#include <cstring>

class Bitstring{
  char string[11];
public:
  Bitstring(const char* newstring){
    strcpy(string, newstring);
    string[10] = '\0';
  }
  void print(){printf("%s\n", string);}
  
  Bitstring operator |(Bitstring& s2) const{
    char newstring[11];
    for(int i=0; i<10; i++){
      newstring[i] = '0' +
        ((string[i]-'0') | (s2.string[i]-'0'));
    }
    newstring[10] = '\0';
    return Bitstring(newstring);
  }
};

int main(){
  Bitstring b1("1001011010");
  Bitstring b2("0100100011");
  (b1 | b2).print();
  return 0;
}