Bitwise Operatoren in C Beheersen: AND, OR, XOR, Shifts & Complement

Wat zijn Bitwise Operatoren?

Bitwise operatoren manipuleren individuele bits van gehele waarden. In tegenstelling tot rekenkundige operatoren die op gehele getallen werken, werken bitwise operatoren op de binaire representatie, wat ze ideaal maakt voor prestatie-kritieke taken zoals vlaggen, bitmasken en laag-niveau apparaatbesturing.

In C zijn de volgende bitwise operatoren beschikbaar:

Bitwise operatoren zijn alleen gedefinieerd voor integrale typen; ze zijn niet toepasbaar op drijvendekommotypen zoals float of double.

De operaties beginnen bij de minst significante bit (LSB) en gaan richting de meest significante bit (MSB). De volgende waarheidstabel vat de binaire resultaten samen:

In de volgende secties duiken we dieper in op elke operator met voorbeelden.

Bitwise AND (&)

De AND-operator retourneert 1 alleen wanneer beide corresponderende bits 1 zijn; anders is het resultaat 0. Het wordt veel gebruikt om ongewenste bits te maskeren.

 Op1 = 0000 1101
Op2 = 0001 1001
Resultaat = 0000 1001

Bitwise OR (|)

De OR-operator retourneert 1 als ten minste één van de bits 1 is. Het is nuttig om specifieke bits in te stellen.

 Op1 = 0000 1101
Op2 = 0001 1001
Resultaat = 0001 1101

Bitwise XOR (^)

De XOR-operator retourneert 1 alleen wanneer de bits verschillen. Het is handig om bits te togglen.

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

Voorbeeldprogramma:

#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;
}

Output:

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

Bitwise Shift Operatoren (<< en >>)

Shift-operatoren verschuiven bits naar links of rechts met een opgegeven aantal.

• operand << n – verschuift links, voegt nullen toe aan de rechterkant.
• operand >> n – verschuift rechts, voegt nullen toe aan de linkerkant.

Voorbeeld met een 4-bit getal 1111:

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

Programma-illustratie:

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

Output:

Linksshift - c = 80
Rechtsshift - c = 5

Bitwise Complement (~)

De complement-operator keert elke bit om: 1 wordt 0 en vice versa. Het is een unaire operator toegepast op een enkele operand.

 0000 1111 → 1111 0000

Voorbeeldprogramma:

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

Output:

Complement - c = -11

Alle Operatoren Samen

Hieronder een beknopt programma dat elke besproken bitwise-operator demonstreert.

#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 (two's complement) */
    printf("NOT - ~x = %d\n", z);
    z = x << 2; /* 192 = 1100 0000 */
    printf("Linksshift - x << 2 = %d\n", z);
    z = x >> 2; /* 12 = 0000 1100 */
    printf("Rechtsshift - x >> 2 = %d\n", z);
    return 0;
}

Resultaat:

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

Belangrijkste Inzichten

• Bitwise operatoren zijn exclusief voor integer-typen en opereren op binair niveau.
• Ze omvatten logische (AND, OR, XOR), shift (links/rechts) en complement (~) operaties.
• Deze operatoren zijn onmisbaar voor taken zoals vlagmanipulatie, laag-niveau I/O en prestatie-kritieke code.