Der C-Präprozessor (CPP) verstehen: Wie er die Kompilierung vereinfacht

Der C-Präprozessor ist nicht Teil des Compilers, sondern ein separater Schritt im Kompilierungsprozess. Einfach ausgedrückt ist der C-Präprozessor ein Textsubstitutionswerkzeug, das dem Compiler anweist, erforderliche Vorverarbeitungsschritte durchzuführen, bevor die eigentliche Kompilierung beginnt. Wir bezeichnen den C-Präprozessor im Folgenden als CPP.

Präprozessor-Direktiven

Alle Präprozessor-Befehle beginnen mit einem Hash-Symbol (#). Es muss das erste nicht-leere Zeichen sein, und zur besseren Lesbarkeit sollte eine Präprozessor-Direktive in der ersten Spalte beginnen. Die folgende Tabelle listet alle wichtigen Präprozessor-Direktiven auf:

Nr.	Direktive & Beschreibung
1	#define Ersetzt ein Präprozessor-Makro.
2	#include Bindet eine bestimmte Header-Datei aus einer anderen Datei ein.
3	#undef Hebt die Definition eines Präprozessor-Makros auf.
4	#ifdef Gibt true zurück, wenn dieses Makro definiert ist.
5	#ifndef Gibt true zurück, wenn dieses Makro nicht definiert ist.
6	#if Prüft, ob eine Kompilierzeit-Bedingung wahr ist.
7	#else Die Alternative für #if.
8	#elif Kombiniert #else und #if in einer Anweisung.
9	#endif Beendet eine bedingte Präprozessor-Anweisung.
10	#error Gibt eine Fehlermeldung auf stderr aus.
11	#pragma Sendet spezielle Befehle an den Compiler auf standardisierte Weise.

Beispiele für Präprozessor-Direktiven

Analysieren Sie die folgenden Beispiele, um die verschiedenen Direktiven zu verstehen.

#define MAX_ARRAY_LENGTH 20

Diese Direktive weist den CPP an, alle Vorkommen von MAX_ARRAY_LENGTH durch 20 zu ersetzen. Verwenden Sie #define für Konstanten, um die Lesbarkeit zu erhöhen.

#include <stdio.h>
#include "myheader.h"

Diese Direktiven weisen den CPP an, stdio.h aus den Systembibliotheken zu holen und den Text in die aktuelle Quelldatei einzufügen. Die nächste Zeile weist den CPP an, myheader.h aus dem lokalen Verzeichnis zu holen und den Inhalt in die aktuelle Quelldatei einzufügen.

#undef FILE_SIZE
#define FILE_SIZE 42

Dies weist den CPP an, ein existierendes FILE_SIZE undefiniert zu machen und es neu als 42 zu definieren.

#ifndef MESSAGE
#define MESSAGE "You wish!"
#endif

Dies weist den CPP an, MESSAGE nur zu definieren, falls MESSAGE noch nicht definiert ist.

#ifdef DEBUG
/* Ihre Debugging-Anweisungen hier */
#endif

Dies weist den CPP an, die eingeschlossenen Anweisungen zu verarbeiten, falls DEBUG definiert ist. Dies ist nützlich, wenn Sie dem GCC-Compiler zur Kompilierzeit das Flag -DDEBUG übergeben. Dadurch wird DEBUG definiert, sodass Sie das Debugging während der Kompilierung ein- und ausschalten können.

Vordefinierte Makros

ANSI C definiert eine Reihe von Makros. Obwohl jedes für die Programmierung verfügbar ist, sollten vordefinierte Makros nicht direkt modifiziert werden.

Nr.	Makro & Beschreibung
1	__DATE__ Das aktuelle Datum als Zeichenliteral im Format "MMM TT JJJJ".
2	__TIME__ Die aktuelle Uhrzeit als Zeichenliteral im Format "HH:MM:SS".
3	__FILE__ Enthält den aktuellen Dateinamen als Zeichenketten-Literal.
4	__LINE__ Enthält die aktuelle Zeilennummer als dezimale Konstante.
5	__STDC__ Definiert als 1, wenn der Compiler dem ANSI-Standard entspricht.

Testen wir das folgende Beispiel:

Live Demo

#include <stdio.h>
int main() {
    printf("File :%s\n", __FILE__ );
    printf("Date :%s\n", __DATE__ );
    printf("Time :%s\n", __TIME__ );
    printf("Line :%d\n", __LINE__ );
    printf("ANSI :%d\n", __STDC__ );
}

Wenn der obige Code in einer Datei test.c kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis:

File :test.c
Date :Jun 2 2012
Time :03:36:24
Line :8
ANSI :1

Präprozessor-Operatoren

Der C-Präprozessor bietet die folgenden Operatoren, um Makros zu erstellen:

Der Makro-Fortsetzungsoperator (\)

Ein Makro ist normalerweise auf eine einzelne Zeile beschränkt. Der Makro-Fortsetzungsoperator (\) wird verwendet, um ein Makro fortzusetzen, das zu lang für eine einzelne Zeile ist. Zum Beispiel:

#define message_for(a, b) \
    printf(#a " and " #b ": We love you!\n")

Der Stringizing-Operator (#)

Der Stringizing-Operator ( '#' ), wenn er innerhalb einer Makrodefinition verwendet wird, konvertiert einen Makro-Parameter in einen String-Konstanten. Dieser Operator kann nur in einem Makro mit einer angegebenen Argument- oder Parameterliste verwendet werden. Zum Beispiel:

Live Demo

#include <stdio.h>
#define message_for(a, b) \
    printf(#a " and " #b ": We love you!\n")
int main(void) {
    message_for(Carole, Debra);
    return 0;
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis:

Carole and Debra: We love you!

Der Token-Pasting-Operator (##)

Der Token-Pasting-Operator (##) innerhalb einer Makrodefinition kombiniert zwei Argumente. Er erlaubt, zwei separate Tokens in der Makrodefinition zu einem einzelnen Token zusammenzufügen. Zum Beispiel:

Live Demo

#include <stdio.h>
#define tokenpaster(n) printf ("token" #n " = %d", token##n)
int main(void) {
    int token34 = 40;
    tokenpaster(34);
    return 0;
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis:

token34 = 40

Dies geschah, weil dieses Beispiel die folgende tatsächliche Ausgabe vom Präprozessor ergibt:

printf ("token34 = %d", token34);

Dieses Beispiel zeigt die Konkatenation von token##n zu token34 und hier haben wir sowohl Stringizing als auch Token-Pasting verwendet.

Der defined()-Operator

Der Präprozessor-Operator defined wird in konstanten Ausdrücken verwendet, um zu bestimmen, ob ein Bezeichner mit #define definiert wurde. Wenn der angegebene Bezeichner definiert ist, ist der Wert wahr (ungleich Null). Wenn das Symbol nicht definiert ist, ist der Wert falsch (null). Der defined-Operator wird wie folgt angegeben:

Live Demo

#include <stdio.h>
#if !defined (MESSAGE)
#define MESSAGE "You wish!"
#endif
int main(void) {
    printf("Here is the message: %s\n", MESSAGE);
    return 0;
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis:

Here is the message: You wish!

Parametrisierte Makros

Eine der mächtigen Funktionen des CPP ist die Fähigkeit, Funktionen mithilfe parametrisierter Makros zu simulieren. Zum Beispiel könnten wir Code haben, um eine Zahl zu quadrieren:

int square(int x) {
    return x * x;
}

Wir können den obigen Code mithilfe eines Makros wie folgt umschreiben:

#define square(x) ((x) * (x))

Makros mit Argumenten müssen mit der #define-Direktive definiert werden, bevor sie verwendet werden können. Die Argumentliste wird in Klammern eingeschlossen und muss unmittelbar auf den Makronamen folgen. Leerzeichen sind zwischen dem Makronamen und der öffnenden Klammer nicht erlaubt. Zum Beispiel:

Live Demo

#include <stdio.h>
#define MAX(x,y) ((x) > (y) ? (x) : (y))
int main(void) {
    printf("Max between 20 and 10 is %d\n", MAX(10, 20));
    return 0;
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis:

Max between 20 and 10 is 20