Infix-Operatoren

Infix-Operatoren sind Operatoren, die zwischen ihren Operanden stehen und eine Vielzahl von Operationen durchführen können. In der C-Programmierung, und somit im Kontext des GNU C Compilers (GCC), gibt es zahlreiche Infix-Operatoren, die in verschiedene Kategorien unterteilt werden können, wie z.B. arithmetische, logische, bitweise und Vergleichsoperatoren. Hier sind einige der wichtigsten Infix-Operatoren, die in C verwendet werden:

Arithmetische Operatoren

Addition (+): Fügt zwei Operanden zusammen.

int sum = a + b;

Subtraktion (-): Subtrahiert den zweiten Operanden vom ersten.

int difference = a - b;

Multiplikation (*): Multipliziert zwei Operanden.

int product = a * b;

Division (/): Teilt den ersten Operanden durch den zweiten.

int quotient = a / b;

Modulus (%): Gibt den Rest der Division des ersten Operanden durch den zweiten zurück.

int remainder = a % b;

Vergleichsoperatoren

Gleich (==): Überprüft, ob zwei Operanden gleich sind.

if (a == b) { /* ... */ }

Ungleich (!=): Überprüft, ob zwei Operanden ungleich sind.

if (a != b) { /* ... */ }

Größer als (>): Überprüft, ob der erste Operand größer als der zweite ist.

if (a > b) { /* ... */ }

Kleiner als (<): Überprüft, ob der erste Operand kleiner als der zweite ist.

if (a < b) { /* ... */ }

Größer oder gleich (>=): Überprüft, ob der erste Operand größer oder gleich dem zweiten ist.

if (a >= b) { /* ... */ }

Kleiner oder gleich (<=): Überprüft, ob der erste Operand kleiner oder gleich dem zweiten ist.

if (a <= b) { /* ... */ }

Logische Operatoren

Logisches UND (&&): Gibt wahr zurück, wenn beide Operanden wahr sind.

if (a && b) { /* ... */ }

Logisches ODER (||): Gibt wahr zurück, wenn mindestens einer der Operanden wahr ist.

if (a || b) { /* ... */ }

Bitweise Operatoren

Bitweises UND (&): Führt ein bitweises UND zwischen zwei Operanden durch.

int result = a & b;

Bitweises ODER (|): Führt ein bitweises ODER zwischen zwei Operanden durch.

int result = a | b;

Bitweises XOR (^): Führt ein bitweises exklusives ODER zwischen zwei Operanden durch.

int result = a ^ b;

Linksschiebung (<<): Verschiebt die Bits des ersten Operanden um die Anzahl der im zweiten Operanden angegebenen Bits nach links.

int result = a << 1;

Rechtsschiebung (>>): Verschiebt die Bits des ersten Operanden um die Anzahl der im zweiten Operanden angegebenen Bits nach rechts.

int result = a >> 1;

Zuweisungsoperatoren

Zuweisung (=): Weist den Wert des rechten Operanden dem linken Operanden zu.

a = b;

Kombinierte Zuweisungsoperatoren: Diese Operatoren kombinieren eine Operation mit einer Zuweisung.

a += b;  // Entspricht a = a + b;
a -= b;  // Entspricht a = a - b;
a *= b;  // Entspricht a = a * b;
a /= b;  // Entspricht a = a / b;
a %= b;  // Entspricht a = a % b;
a &= b;  // Entspricht a = a & b;
a |= b;  // Entspricht a = a | b;
a ^= b;  // Entspricht a = a ^ b;
a <<= b; // Entspricht a = a << b;
a >>= b; // Entspricht a = a >> b;

Beispiel für die Verwendung von Infix-Operatoren

Hier ist ein einfaches Beispiel, das verschiedene Infix-Operatoren kombiniert:

#include <stdio.h>

int main() {
    int a = 10;
    int b = 5;
    int sum = a + b;
    int difference = a - b;
    int product = a * b;
    int quotient = a / b;
    int remainder = a % b;

    int isEqual = (a == b);
    int isNotEqual = (a != b);
    int isGreater = (a > b);
    int isLess = (a < b);
    int isGreaterOrEqual = (a >= b);
    int isLessOrEqual = (a <= b);

    int logicalAnd = (a && b);
    int logicalOr = (a || b);

    int bitwiseAnd = a & b;
    int bitwiseOr = a | b;
    int bitwiseXor = a ^ b;
    int leftShift = a << 1;
    int rightShift = a >> 1;

    printf("Sum: %d\n", sum);
    printf("Difference: %d\n", difference);
    printf("Product: %d\n", product);
    printf("Quotient: %d\n", quotient);
    printf("Remainder: %d\n", remainder);

    printf("Is Equal: %d\n", isEqual);
    printf("Is Not Equal: %d\n", isNotEqual);
    printf("Is Greater: %d\n", isGreater);
    printf("Is Less: %d\n", isLess);
    printf("Is Greater Or Equal: %d\n", isGreaterOrEqual);
    printf("Is Less Or Equal: %d\n", isLessOrEqual);

    printf("Logical AND: %d\n", logicalAnd);
    printf("Logical OR: %d\n", logicalOr);

    printf("Bitwise AND: %d\n", bitwiseAnd);
    printf("Bitwise OR: %d\n", bitwiseOr);
    printf("Bitwise XOR: %d\n", bitwiseXor);
    printf("Left Shift: %d\n", leftShift);
    printf("Right Shift: %d\n", rightShift);

    return 0;
}

Dieses Beispiel zeigt die Verwendung verschiedener Infix-Operatoren und wie sie in einem einfachen Programm verwendet werden können.

---

< Zurück (Präfixoperatoren)

< Hauptseite >

Weiter (Bedingte Kompilierung) >