C++ Preprocessor

De preprocessors zijn de richtlijnen, die instructies geven aan de compiler om de informatie voor te verwerken voordat de eigenlijke compilatie begint.

Alle preprocessor-richtlijnen beginnen met # en alleen witruimtetekens mogen vóór een preprocessor-richtlijn op een regel verschijnen. Preprocessor-richtlijnen zijn geen C++-instructies, dus ze eindigen niet op een puntkomma (;).

Je hebt al een #include . gezien richtlijn in alle voorbeelden. Deze macro wordt gebruikt om een headerbestand in het bronbestand op te nemen.

Er zijn een aantal preprocessor-richtlijnen die door C++ worden ondersteund, zoals #include, #define, #if, #else, #line, enz. Laten we eens kijken naar belangrijke richtlijnen −

De #define Preprocessor

De #define preprocessor-richtlijn creëert symbolische constanten. De symbolische constante wordt een macro . genoemd en de algemene vorm van de richtlijn is −

#define macro-name replacement-text

Als deze regel in een bestand verschijnt, worden alle volgende macro's in dat bestand vervangen door vervangende tekst voordat het programma wordt gecompileerd. Bijvoorbeeld −

#include <iostream>
using namespace std;

#define PI 3.14159

int main () {
   cout << "Value of PI :" << PI << endl; 

   return 0;
}

Laten we nu de voorbewerking van deze code doen om het resultaat te zien, ervan uitgaande dat we het broncodebestand hebben. Laten we het dus compileren met de optie -E en het resultaat omleiden naar test.p. Als je nu test.p aanvinkt, zal het veel informatie bevatten en onderaan vind je de waarde als volgt vervangen −

$gcc -E test.cpp > test.p

...
int main () {
   cout << "Value of PI :" << 3.14159 << endl; 
   return 0;
}

Functie-achtige macro's

U kunt #define gebruiken om een macro te definiëren die het argument als volgt zal aannemen −

Live demo

#include <iostream>
using namespace std;

#define MIN(a,b) (((a)<(b)) ? a : b)

int main () {
   int i, j;
   
   i = 100;
   j = 30;
   
   cout <<"The minimum is " << MIN(i, j) << endl;

   return 0;
}

Als we bovenstaande code compileren en uitvoeren, zou dit het volgende resultaat opleveren −

The minimum is 30

Voorwaardelijke compilatie

Er zijn verschillende richtlijnen die kunnen worden gebruikt om selectieve delen van de broncode van uw programma te compileren. Dit proces wordt voorwaardelijke compilatie genoemd.

De voorwaardelijke preprocessor-constructie lijkt veel op de 'if'-selectiestructuur. Beschouw de volgende preprocessorcode −

#ifndef NULL
   #define NULL 0
#endif

U kunt een programma compileren voor foutopsporing. U kunt het debuggen ook als volgt in- of uitschakelen met een enkele macro −

#ifdef DEBUG
   cerr <<"Variable x = " << x << endl;
#endif

Dit zorgt ervoor dat de cerr statement dat in het programma moet worden gecompileerd als de symbolische constante DEBUG is gedefinieerd vóór richtlijn #ifdef DEBUG. U kunt het #if 0-statement gebruiken om een gedeelte van het programma als volgt te becommentariëren −

#if 0
   code prevented from compiling
#endif

Laten we het volgende voorbeeld proberen −

Live demo

#include <iostream>
using namespace std;
#define DEBUG

#define MIN(a,b) (((a)<(b)) ? a : b)

int main () {
   int i, j;
   
   i = 100;
   j = 30;

#ifdef DEBUG
   cerr <<"Trace: Inside main function" << endl;
#endif

#if 0
   /* This is commented part */
   cout << MKSTR(HELLO C++) << endl;
#endif

   cout <<"The minimum is " << MIN(i, j) << endl;

#ifdef DEBUG
   cerr <<"Trace: Coming out of main function" << endl;
#endif

   return 0;
}

Als we bovenstaande code compileren en uitvoeren, zou dit het volgende resultaat opleveren −

The minimum is 30
Trace: Inside main function
Trace: Coming out of main function

De # en ## operators

De preprocessor-operators # en ## zijn beschikbaar in C++ en ANSI/ISO C. De operator # zorgt ervoor dat een vervangend teksttoken wordt geconverteerd naar een tekenreeks tussen aanhalingstekens.

Overweeg de volgende macrodefinitie −

Live demo

#include <iostream>
using namespace std;

#define MKSTR( x ) #x

int main () {

   cout << MKSTR(HELLO C++) << endl;

   return 0;
}

Als we bovenstaande code compileren en uitvoeren, zou dit het volgende resultaat opleveren −

HELLO C++

Laten we eens kijken hoe het werkte. Het is eenvoudig te begrijpen dat de C++-preprocessor de regel omdraait −

cout << MKSTR(HELLO C++) << endl;

Bovenstaande regel wordt de volgende regel −

cout << "HELLO C++" << endl;

De operator ## wordt gebruikt om twee tokens samen te voegen. Hier is een voorbeeld −

#define CONCAT( x, y )  x ## y

Wanneer CONCAT in het programma verschijnt, worden de argumenten aaneengeschakeld en gebruikt om de macro te vervangen. CONCAT(HELLO, C++) wordt bijvoorbeeld als volgt vervangen door "HELLO C++" in het programma.

Live demo

#include <iostream>
using namespace std;

#define concat(a, b) a ## b
int main() {
   int xy = 100;
   
   cout << concat(x, y);
   return 0;
}

Als we bovenstaande code compileren en uitvoeren, zou dit het volgende resultaat opleveren −

Laten we eens kijken hoe het werkte. Het is eenvoudig te begrijpen dat de C++ preprocessor −

. transformeert

cout << concat(x, y);

Bovenstaande regel wordt omgezet in de volgende regel −

cout << xy;

Vooraf gedefinieerde C++-macro's

C++ biedt een aantal vooraf gedefinieerde macro's die hieronder worden genoemd −

Zr.Nee	Macro en beschrijving
1	__LINE__ Dit bevat het huidige regelnummer van het programma wanneer het wordt gecompileerd.
2	__FILE__ Dit bevat de huidige bestandsnaam van het programma wanneer het wordt gecompileerd.
3	__DATUM__ Deze bevat een string van de vorm maand/dag/jaar die de datum is van de vertaling van het bronbestand naar objectcode.
4	__TIME__ Deze bevat een string van de vorm hour:minute:second dat is het tijdstip waarop het programma is gecompileerd.

Laten we een voorbeeld zien voor alle bovenstaande macro's −

Live demo

#include <iostream>
using namespace std;

int main () {
   cout << "Value of __LINE__ : " << __LINE__ << endl;
   cout << "Value of __FILE__ : " << __FILE__ << endl;
   cout << "Value of __DATE__ : " << __DATE__ << endl;
   cout << "Value of __TIME__ : " << __TIME__ << endl;

   return 0;
}

Als we bovenstaande code compileren en uitvoeren, zou dit het volgende resultaat opleveren −

Value of __LINE__ : 6
Value of __FILE__ : test.cpp
Value of __DATE__ : Feb 28 2011
Value of __TIME__ : 18:52:48

C++-sjablonen C++ Signaalverwerking

C Taal