De C-preprocessor (CPP) begrijpen: Hoe het de compilatie vereenvoudigt

De C-preprocessor is geen onderdeel van de compiler, maar een afzonderlijke stap in het compilatieproces. In eenvoudige termen is een C-preprocessor slechts een tekstvervangingstool die de compiler instructeert om de benodigde voorverwerking uit te voeren voordat de eigenlijke compilatie begint. We verwijzen naar de C-preprocessor als CPP.

Alle preprocessor-commando's beginnen met een hekje (#). Dit moet het eerste niet-blanke teken zijn, en voor leesbaarheid moet een preprocessor-directive in de eerste kolom beginnen. De volgende sectie geeft een overzicht van alle belangrijke preprocessor-directives:

Nr.	Directive & Beschrijving
1	#define Vervangt een preprocessor-macro.
2	#include Voegt een specifieke header uit een ander bestand in.
3	#undef Maakt een preprocessor-macro ongedefinieerd.
4	#ifdef Geeft true terug als deze macro gedefinieerd is.
5	#ifndef Geeft true terug als deze macro niet gedefinieerd is.
6	#if Test of een compile-tijd voorwaarde waar is.
7	#else De alternatief voor #if.
8	#elif #else en #if in één statement.
9	#endif Beëindigt preprocessor-voorwaardelijke compilatie.
10	#error Print foutmelding op stderr.
11	#pragma Geeft speciale opdrachten aan de compiler op een gestandaardiseerde manier.

Preprocessor Voorbeelden

Analyseer de volgende voorbeelden om de verschillende directives te begrijpen.

#define MAX_ARRAY_LENGTH 20

Deze directive vertelt de CPP om instanties van MAX_ARRAY_LENGTH te vervangen door 20. Gebruik #define voor constanten om de leesbaarheid te vergroten.

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

Deze directives vertellen de CPP om stdio.h op te halen uit de systeembibliotheken en de tekst toe te voegen aan het huidige bronbestand. De volgende regel vertelt CPP om myheader.h op te halen uit de lokale map en de inhoud toe te voegen aan het huidige bronbestand.

#undef FILE_SIZE
#define FILE_SIZE 42

Dit vertelt de CPP om de bestaande FILE_SIZE ongedefinieerd te maken en deze te definiëren als 42.

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

Dit vertelt de CPP om MESSAGE alleen te definiëren als MESSAGE nog niet gedefinieerd is.

#ifdef DEBUG
/* Jouw debug-statements hier */
#endif

Dit vertelt de CPP om de ingesloten statements te verwerken als DEBUG gedefinieerd is. Dit is nuttig als je de -DDEBUG vlag doorgeeft aan de gcc-compiler tijdens de compilatie. Dit definieert DEBUG, zodat je debugging aan en uit kunt zetten tijdens de compilatie.

Voorgedefinieerde Macro's

ANSI C definieert een aantal macro's. Hoewel elk beschikbaar is voor gebruik in programmering, mogen de voorgedefinieerde macro's niet direct worden gewijzigd.

Nr.	Macro & Beschrijving
1	__DATE__ De huidige datum als een karakterliteral in formaat "MMM DD JJJJ".
2	__TIME__ De huidige tijd als een karakterliteral in formaat "HH:MM:SS".
3	__FILE__ Bevat de huidige bestandsnaam als een stringliteral.
4	__LINE__ Bevat het huidige regelnummer als een decimale constante.
5	__STDC__ Gedefinieerd als 1 wanneer de compiler voldoet aan de ANSI-standaard.

Laten we het volgende voorbeeld proberen:

Live Demo

#include <stdio.h>
int main() {
    printf("Bestand :%s\n", __FILE__ );
    printf("Datum :%s\n", __DATE__ );
    printf("Tijd :%s\n", __TIME__ );
    printf("Regel :%d\n", __LINE__ );
    printf("ANSI :%d\n", __STDC__ );
}

Wanneer de bovenstaande code in een bestand test.c wordt gecompileerd en uitgevoerd, produceert het het volgende resultaat:

Bestand :test.c
Datum :Jun 2 2012
Tijd :03:36:24
Regel :8
ANSI :1

Preprocessor Operatoren

De C-preprocessor biedt de volgende operatoren om macro's te maken:

De Macro Continuatie (\) Operator

Een macro is normaal gesproken beperkt tot één regel. De macro-continuatie-operator (\) wordt gebruikt om een macro voort te zetten die te lang is voor één regel. Bijvoorbeeld:

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

De Stringize (#) Operator

De stringize- of hekje-operator ('#'), wanneer gebruikt binnen een macro-definitie, converteert een macro-parameter naar een stringconstante. Deze operator mag alleen gebruikt worden in een macro met een gespecificeerde argumentenlijst. Bijvoorbeeld:

Live Demo

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

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, produceert het het volgende resultaat:

Carole en Debra: We love you!

De Token Plak (##) Operator

De token-plakoperator (##) binnen een macro-definitie combineert twee argumenten. Het stelt twee losse tokens in de macro-definitie in staat om samengevoegd te worden tot een enkel token. Bijvoorbeeld:

Live Demo

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

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, produceert het het volgende resultaat:

token34 = 40

Dit gebeurde omdat dit voorbeeld resulteert in de volgende echte uitvoer van de preprocessor:

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

Dit voorbeeld toont de concatenatie van token##n tot token34 en hier hebben we zowel stringize als token-plak gebruikt.

De Defined() Operator

De preprocessor defined operator wordt in constante expressies gebruikt om te bepalen of een identifier gedefinieerd is met #define. Als de gespecificeerde identifier gedefinieerd is, is de waarde true (niet-nul). Als het symbool niet gedefinieerd is, is de waarde false (nul). De defined operator wordt als volgt gespecificeerd:

Live Demo

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

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, produceert het het volgende resultaat:

Hier is het bericht: You wish!

Geparametriseerde Macro's

Een van de krachtige functies van de CPP is de mogelijkheid om functies te simuleren met behulp van geparametriseerde macro's. Stel dat we code hebben om het kwadraat van een getal te berekenen:

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

We kunnen de bovenstaande code herschrijven met een macro als volgt:

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

Macro's met argumenten moeten gedefinieerd worden met de #define directive voordat ze gebruikt kunnen worden. De argumentenlijst wordt tussen haakjes gezet en moet onmiddellijk na de macro-naam volgen. Spaties zijn niet toegestaan tussen de macro-naam en de openende haak. Bijvoorbeeld:

Live Demo

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

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, produceert het het volgende resultaat:

Max tussen 20 en 10 is 20