Präfixoperatoren

Präfixoperatoren sind Operatoren, die vor ihren Operanden stehen und verschiedene Arten von Operationen durchführen können. In der C-Programmierung, und somit auch im Kontext des GNU C Compilers (GCC), gibt es mehrere Präfixoperatoren, die eine wichtige Rolle spielen. Hier sind einige der wichtigsten Präfixoperatoren, die in C verwendet werden:

Inkrement (++) und Dekrement (--)

Inkrement (++): Erhöht den Wert einer Variablen um 1.

int a = 5;
++a;  // a ist jetzt 6

Dekrement (--): Verringert den Wert einer Variablen um 1.

int b = 5;
--b;  // b ist jetzt 4

Dereferenzierungsoperator (*)

Dereferenzierungsoperator (*): Wird verwendet, um auf den Wert zuzugreifen, auf den ein Zeiger zeigt.

int x = 10;
int *ptr = &x;
int y = *ptr;  // y ist jetzt 10

Adressoperator (&)

Adressoperator (&): Gibt die Adresse einer Variablen zurück.

int z = 20;
int *ptr = &z;  // ptr enthält die Adresse von z

Logisches Nicht (!)

Logisches Nicht (!): Negiert einen logischen Wert. Wenn der Operand wahr ist, wird er falsch und umgekehrt.

int flag = 0;
if (!flag) {
    // Dieser Block wird ausgeführt, da !0 wahr ist
}

Bitweises Nicht (~)

Bitweises Nicht (~): Invertiert alle Bits eines Wertes.

unsigned int num = 0b1010;  // Binär: 1010
unsigned int result = ~num; // Binär: 0101 (in 4-Bit-Darstellung)

Vorzeichenwechsel (-)

Vorzeichenwechsel (-): Ändert das Vorzeichen eines Wertes.

int positive = 5;
int negative = -positive;  // negative ist jetzt -5

Größe des Operators (sizeof)

Größe des Operators (sizeof): Gibt die Größe eines Datentyps oder einer Variable in Bytes zurück.

int a = 5;
size_t size = sizeof(a);  // size ist die Anzahl der Bytes, die ein int belegt

Beispiel für die Verwendung von Präfixoperatoren

Hier ist ein einfaches Beispiel, das verschiedene Präfixoperatoren kombiniert:

#include <stdio.h>

int main() {
    int a = 5;
    int b = 10;
    int *ptr = &a;

    // Inkrement und Dekrement
    ++a;  // a ist jetzt 6
    --b;  // b ist jetzt 9

    // Dereferenzierungs- und Adressoperator
    int c = *ptr;  // c ist jetzt 6 (Wert von a)
    int *ptr_b = &b;

    // Logisches Nicht
    int flag = 0;
    if (!flag) {
        printf("Flag ist falsch\n");
    }

    // Bitweises Nicht
    unsigned int num = 0b1010;
    unsigned int result = ~num;

    // Vorzeichenwechsel
    int positive = 5;
    int negative = -positive;

    // Größe des Operators
    size_t size_of_int = sizeof(int);

    // Ausgabe der Ergebnisse
    printf("a: %d, b: %d, c: %d\n", a, b, c);
    printf("result (bitweises Nicht): %u\n", result);
    printf("negative: %d\n", negative);
    printf("Größe eines int: %zu Bytes\n", size_of_int);

    return 0;
}

Dieses Beispiel zeigt die Verwendung der verschiedenen Präfixoperatoren und wie sie in einem einfachen Programm verwendet werden können.

---

< Zurück (Präprozessor-Direktiven)

< Hauptseite >

Weiter (Infix-Operatoren) >