Bitweise Operatoren in C meistern: AND, OR, XOR, Shifts & Komplement

Was sind bitweise Operatoren?

Bitweise Operatoren manipulieren einzelne Bits von Ganzzahlwerten. Im Gegensatz zu arithmetischen Operatoren, die auf ganzen Zahlen arbeiten, wirken bitweise Operatoren auf der binären Repräsentation, was sie ideal für Performance-kritische Aufgaben wie Flags, Bitmasks und Low-Level-Gerätesteuerung macht.

In C sind folgende bitweise Operatoren verfügbar:

Operator	Bedeutung
&	Bitweises UND (AND)
|	Bitweises ODER (OR)
^	Bitweises XOR (exklusives ODER)
~	Bitweises NICHT (Einerkomplement)
<<	Links-Shift
>>	Rechts-Shift

Bitweise Operatoren sind nur für integrale Typen definiert; sie sind nicht auf Gleitkommatypen wie float oder double anwendbar.

Die Operationen beginnen am least significant bit (LSB) und gehen Richtung most significant bit (MSB). Die folgende Wahrheitstabelle fasst die binären Ergebnisse zusammen:

Operand x	Operand y	x & y	x | y	x ^ y
0	0	0	0	0
0	1	0	1	1
1	0	0	1	1
1	1	1	1	0

In den folgenden Abschnitten gehen wir tiefer auf jeden Operator mit Beispielen ein.

Bitweises UND (&)

Der AND-Operator gibt 1 nur zurück, wenn beide korrespondierenden Bits 1 sind; sonst 0. Er wird häufig verwendet, um unerwünschte Bits zu maskieren.

Op1 = 0000 1101
Op2 = 0001 1001
Result = 0000 1001

Bitweises ODER (|)

Der OR-Operator gibt 1 zurück, wenn mindestens eines der Bits 1 ist. Nützlich zum Setzen spezifischer Bits.

Op1 = 0000 1101
Op2 = 0001 1001
Result = 0001 1101

Bitweises XOR (^)

Der XOR-Operator gibt 1 nur zurück, wenn die Bits sich unterscheiden. Praktisch zum Toggeln von Bits.

Op1 = 0000 1101
Op2 = 0001 1001
Result = 0001 0100

Beispielprogramm:

#include <stdio.h>
int main() {
    int a = 20; /* 20 = 010100 */
    int b = 21; /* 21 = 010101 */
    int c = 0;
    c = a & b; /* 20 = 010100 */
    printf("AND - c = %d\n", c);
    c = a | b; /* 21 = 010101 */
    printf("OR - c = %d\n", c);
    c = a ^ b; /* 1 = 000001 */
    printf("XOR - c = %d\n", c);
    return 0;
}

Ausgabe:

AND - c = 20
OR - c = 21
XOR - c = 1

Bitweise Shift-Operatoren (<< und >>)

Shift-Operatoren verschieben Bits um eine angegebene Anzahl nach links oder rechts.

• operand << n – schiebt links, fügt Nullen rechts ein.
• operand >> n – schiebt rechts, fügt Nullen links ein.

Beispiel mit 4-Bit-Zahl 1111:

x << 2 → 1100
x >> 2 → 0011

Programm-Illustration:

#include <stdio.h>
int main() {
    int a = 20; /* 20 = 010100 */
    int c = 0;
    c = a << 2; /* 80 = 101000 */
    printf("Left shift - c = %d\n", c);
    c = a >> 2; /* 5 = 000101 */
    printf("Right shift - c = %d\n", c);
    return 0;
}

Ausgabe:

Left shift - c = 80
Right shift - c = 5

Bitweises Komplement (~)

Der Komplement-Operator kehrt jedes Bit um: 1 wird 0 und umgekehrt. Es ist ein unärer Operator, der auf einen einzelnen Operanden angewendet wird.

0000 1111 → 1111 0000

Beispielprogramm:

#include <stdio.h>
int main() {
    int a = 10; /* 10 = 001010 */
    int c = ~a; /* -11 in Zweierkomplement */
    printf("Complement - c = %d\n", c);
    return 0;
}

Ausgabe:

Complement - c = -11

Alle Operatoren zusammen

Unten ein prägnantes Programm, das jeden besprochenen bitweisen Operator demonstriert.

#include <stdio.h>
int main() {
    unsigned int x = 48; /* 0011 0000 */
    unsigned int y = 13; /* 0000 1101 */
    int z = 0;
    z = x & y; /* 0 = 0000 0000 */
    printf("AND - x & y = %d\n", z);
    z = x | y; /* 61 = 0011 1101 */
    printf("OR - x | y = %d\n", z);
    z = x ^ y; /* 61 = 0011 1101 */
    printf("XOR - x ^ y = %d\n", z);
    z = ~x; /* -49 = 1111 0100 (Zweierkomplement) */
    printf("NOT - ~x = %d\n", z);
    z = x << 2; /* 192 = 1100 0000 */
    printf("Left shift - x << 2 = %d\n", z);
    z = x >> 2; /* 12 = 0000 1100 */
    printf("Right shift - x >> 2 = %d\n", z);
    return 0;
}

Ergebnis:

AND - x & y = 0
OR - x | y = 61
XOR - x ^ y = 61
NOT - ~x = -49
Left shift - x << 2 = 192
Right shift - x >> 2 = 12

Wichtigste Erkenntnisse

• Bitweise Operatoren sind exklusiv für Integer-Typen und operieren auf binärer Ebene.
• Sie umfassen logische (AND, OR, XOR), Shift (links/rechts) und Komplement (~) Operationen.
• Diese Operatoren sind unverzichtbar für Flag-Manipulation, Low-Level I/O und Performance-kritischen Code.