GNU C Compiler

Aus C und Assembler mit Raspberry

Der GNU C Compiler, häufig als GCC (GNU Compiler Collection) bezeichnet, ist ein weit verbreiteter Compiler, der ursprünglich für die Programmiersprache C entwickelt wurde. Heute unterstützt GCC eine Vielzahl von Programmiersprachen und Prozessorarchitekturen. Hier sind einige wichtige Punkte über den GNU C Compiler:

Präprozessor-Direktiven

Präprozessor-Direktiven sind Anweisungen, die vor der eigentlichen Kompilierung des Codes durch den C-Präprozessor verarbeitet werden. Diese Direktiven beginnen immer mit dem #-Zeichen und können eine Vielzahl von Aufgaben erfüllen, wie z.B. das Einfügen von Header-Dateien, das Definieren von Makros, das Bedingungskompilieren und mehr. Hier sind einige der wichtigsten Präprozessor-Direktiven, die im GCC verwendet werden:

Präprozessor-Direktiven
#include Diese Direktive wird verwendet, um den Inhalt einer anderen Datei in die aktuelle Datei einzufügen
#define
#undef		 Mit #define können Makros definiert werden. Makros sind Platzhalter, die durch ihren definierten Wert ersetzt werden, bevor die eigentliche Kompilierung beginnt.
#undef wird verwendet, um eine zuvor definierte Makrodefinition aufzuheben.
#if
#ifdef
#ifndef
#else
#elif
#endif		 Diese Direktiven ermöglichen die bedingte Kompilierung von Codeabschnitten. Dies ist besonders nützlich für plattformspezifischen Code oder für das Ein- und Ausschalten von Debugging-Funktionen.

Beispiel für den Einsatz von Präprozessor-Direktiven

#include <stdio.h>

#define PI 3.14159
#define AREA_OF_CIRCLE(r) (PI * (r) * (r))

#ifdef DEBUG
    #define DEBUG_PRINT(msg) printf("DEBUG: %s\n", msg)
#else
    #define DEBUG_PRINT(msg)
#endif

int main() {
    double radius = 5.0;
    double area = AREA_OF_CIRCLE(radius);

    DEBUG_PRINT("Berechnung abgeschlossen");
    printf("Die Fläche des Kreises mit Radius %.2f ist %.2f\n", radius, area);

    return 0;
}

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.

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 &gt;= b) { /* ... */ }

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

if (a &lt;= 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.

Bedingte Kompilierung

Bedingte Kompilierung mit dem GCC-Compiler (GNU Compiler Collection) ist eine Technik, die es ermöglicht, bestimmte Teile des Codes abhängig von definierten Bedingungen zu kompilieren oder auszulassen. Dies ist besonders nützlich, um plattform- oder konfigurationsspezifischen Code zu schreiben und zu verwalten, Debugging zu aktivieren oder zu deaktivieren, oder experimentelle Funktionen einzuschließen.

Hier sind die wichtigsten Aspekte der bedingten Kompilierung im Zusammenhang mit GCC:

Präprozessor-Direktiven für Bedingte Kompilierung

#if,#else und #endif: Diese Präprozessor-Direktiven werden verwendet, um Codeblöcke basierend auf Bedingungen ein- oder auszuschließen.

<syntaxhighlight lang="C">

  1. if defined(DEBUG)
   // Code wird nur kompiliert, wenn DEBUG definiert ist
   printf("Debug mode\n");
  1. else
   // Alternativer Code wird kompiliert, wenn DEBUG nicht definiert ist
   printf("Production mode\n");
  1. endif

<\syntaxhighlight> #ifdef und #ifndef: Diese Direktiven prüfen, ob ein Symbol definiert ist oder nicht. <syntaxhighlight lang="C">

  1. ifdef DEBUG
   // Dieser Code wird kompiliert, wenn DEBUG definiert ist
   printf("Debug mode\n");
  1. endif
  1. ifndef RELEASE
   // Dieser Code wird kompiliert, wenn RELEASE nicht definiert ist
   printf("Not in release mode\n");
  1. endif

<\syntaxhighlight> #elif: Diese Direktive ermöglicht zusätzliche Bedingungen innerhalb einer #if-Kette. <syntaxhighlight lang="C">

  1. if LEVEL == 1
   printf("Level 1\n");
  1. elif LEVEL == 2
   printf("Level 2\n");
  1. else
   printf("Other level\n");
  1. endif

<\syntaxhighlight> #define und #undef: Verwenden Sie diese Direktiven, um Symbole zu definieren oder deren Definition aufzuheben. <syntaxhighlight lang="C">

  1. define FEATURE_X
  2. undef FEATURE_X

<\syntaxhighlight>

Praktische Anwendungen

Debugging und Entwicklungsmodi

Bedingte Kompilierung ist besonders nützlich, um Debugging-Funktionalitäten ein- oder auszuschalten: <syntaxhighlight lang="C">

  1. include <stdio.h>
  1. define DEBUG

int main() { 

   int val = 42;

   #ifdef DEBUG
       printf("Debug: val = %d\n", val);
   #else
       printf("Release: val = %d\n", val);
   #endif

   return 0;

} <\syntaxhighlight> Wenn das Symbol DEBUG definiert ist, wird die Debugging-Ausgabe aktiviert. Andernfalls wird die Release-Ausgabe verwendet.

Plattformübergreifende Kompilierung

Bedingte Kompilierung kann verwendet werden, um spezifischen Code für verschiedene Betriebssysteme oder Architekturen zu schreiben: <syntaxhighlight lang="C">

  1. include <stdio.h>

int main() { 

   #ifdef _WIN32
       printf("Running on Windows\n");
   #elif __linux__
       printf("Running on Linux\n");
   #elif __APPLE__
       printf("Running on macOS\n");
   #else
       printf("Unknown Platform\n");
   #endif

   return 0;

} <\syntaxhighlight> Hier wird basierend auf dem Zielbetriebssystem unterschiedlicher Code kompiliert.

Feature-Toggles

Mit bedingter Kompilierung können Funktionen basierend auf definierten Symbolen aktiviert oder deaktiviert werden: <syntaxhighlight lang="C">

  1. include <stdio.h>
  1. define FEATURE_X

int main() { 

   #ifdef FEATURE_X
       printf("Feature X is enabled\n");
   #else
       printf("Feature X is disabled\n");
   #endif

   return 0;

} <\syntaxhighlight> Je nachdem, ob FEATURE_X definiert ist oder nicht, wird der entsprechende Code kompiliert.

Kompilierungsflags mit GCC

Symbole können direkt beim Aufruf des Compilers definiert oder entfernt werden, was die Flexibilität erhöht: <syntaxhighlight lang="Shell"> gcc -DDEBUG -o myprogram myprogram.c <\syntaxhighlight> Hier definiert -DDEBUG das Symbol DEBUG während der Kompilierung.

Beispiel für Kompilierung mit GCC

Angenommen, wir haben den folgenden C-Code: <syntaxhighlight lang="C">

  1. include <stdio.h>

int main() { 

   #ifdef DEBUG
       printf("Debug mode enabled\n");
   #else
       printf("Production mode\n");
   #endif

   return 0;

} <\syntaxhighlight> Wir können den Code mit und ohne Debugging-Informationen kompilieren:

Mit Debugging: <syntaxhighlight lang="Shell"> gcc -DDEBUG -o myprogram myprogram.c ./myprogram # Ausgabe: Debug mode enabled <\syntaxhighlight> Ohne Debugging: <syntaxhighlight lang="Shell"> gcc -o myprogram myprogram.c ./myprogram # Ausgabe: Production mode <\syntaxhighlight>

Abgerufen von „https://satyria.de/arm/index.php?title=GNU_C_Compiler&oldid=447“