Preprocessors zijn programma's die de broncode verwerken voordat deze wordt gecompileerd. Er zijn verschillende stappen tussen het schrijven van een programma en het uitvoeren van een programma in C. Laten we deze stappen eens bekijken voordat we daadwerkelijk over preprocessors gaan leren.
De tussenstappen ziet u in bovenstaand diagram. De door programmeurs geschreven broncode wordt eerst opgeslagen in een bestand, laat de naam maar staan programma.c . Dit bestand wordt vervolgens verwerkt door preprocessors en er wordt een uitgebreid broncodebestand gegenereerd met de naam program.i. Dit uitgebreide bestand wordt door de compiler samengesteld en er wordt een objectcodebestand gegenereerd met de naam program.obj. Ten slotte koppelt de linker dit objectcodebestand aan de objectcode van de bibliotheekfuncties om het uitvoerbare bestand program.exe te genereren.
Preprocessorrichtlijnen in C
Preprocessorprogramma's bieden preprocessorrichtlijnen die de compiler vertellen de broncode voor te verwerken voordat deze wordt gecompileerd. Al deze preprocessor-richtlijnen beginnen met een ‘#’ (hash)-symbool. Het ‘#’-symbool geeft aan dat elke instructie die met een ‘#’ begint, naar het preprocessorprogramma zal gaan om te worden uitgevoerd. We kunnen deze preprocessor-richtlijnen overal in ons programma plaatsen.
Voorbeelden van enkele preprocessorrichtlijnen zijn: #erbij betrekken , #definiëren , #ifndef, enz.
Opmerking Vergeet niet dat de # symbool geeft alleen een pad naar de preprocessor, en een opdracht zoals include wordt verwerkt door het preprocessorprogramma. #include neemt bijvoorbeeld de code of inhoud van het opgegeven bestand in uw programma op.
Lijst met preprocessorrichtlijnen in C
De volgende tabel bevat alle preprocessorrichtlijnen in C:
| Preprocessor-richtlijnen | Beschrijving |
|---|---|
| #definiëren | Wordt gebruikt om een macro te definiëren |
| #undef | Wordt gebruikt om de definitie van een macro ongedaan te maken |
| #erbij betrekken | Wordt gebruikt om een bestand op te nemen in het broncodeprogramma |
| #ifdef | Wordt gebruikt om een codegedeelte op te nemen als een bepaalde macro is gedefinieerd door #define |
| #ifndef | Wordt gebruikt om een codegedeelte op te nemen als een bepaalde macro niet is gedefinieerd door #define |
| #als | Controleer op de opgegeven voorwaarde |
| #anders | Alternatieve code die wordt uitgevoerd als #if mislukt |
| #stop als | Wordt gebruikt om het einde van #if, #ifdef en #ifndef te markeren |
Deze preprocessors kunnen worden geclassificeerd op basis van het type functie dat ze uitvoeren.
Soorten C-preprocessors
Er zijn 4 hoofdtypen preprocessorrichtlijnen:
- Macro's
- Bestandsopname
- Voorwaardelijke compilatie
- Andere richtlijnen
Laten we nu elk van deze richtlijnen in detail leren kennen.
1. Macro's
In C zijn macro's stukjes code in een programma die een bepaalde naam krijgen. Telkens wanneer de compiler deze naam tegenkomt, vervangt de compiler de naam door het daadwerkelijke stukje code. De '#definiëren' richtlijn wordt gebruikt om een macro te definiëren.
Syntaxis van macrodefinitie
#define token value>
waarbij na voorbewerking de teken zal worden uitgebreid naar zijn waarde in het programma.
Voorbeeld van macro
C
// C Program to illustrate the macro> #include> // macro definition> #define LIMIT 5> int> main()> {> >for> (>int> i = 0; i printf('%d
', i); } return 0; }> |
>
>Uitvoer
0 1 2 3 4>
Wanneer in het bovenstaande programma de compiler het woord LIMIT uitvoert, wordt dit vervangen door 5. Het woord 'BEGRENZING' in de macrodefinitie wordt een macrosjabloon genoemd En ‘5’ is macro-expansie.
Opmerking Er staat geen puntkomma (;) aan het einde van de macrodefinitie. Macrodefinities hebben geen puntkomma nodig om te eindigen.
Er zijn er ook enkele Vooraf gedefinieerde macro's in C die nuttig zijn bij het bieden van verschillende functionaliteiten aan ons programma.
Macro's met argumenten
We kunnen ook argumenten doorgeven aan macro's. Macro's die met argumenten zijn gedefinieerd, werken op dezelfde manier als functies.
Voorbeeld
#define foo( a, b ) a + b #define func(r) r * r>
Laten we dit begrijpen met een programma:
C
// C Program to illustrate function like macros> #include> // macro with parameter> #define AREA(l, b) (l * b)> int> main()> {> >int> l1 = 10, l2 = 5, area;> >area = AREA(l1, l2);> >printf>(>'Area of rectangle is: %d'>, area);> >return> 0;> }> |
>
>Uitvoer
Area of rectangle is: 50>
We kunnen uit het bovenstaande programma zien dat wanneer de compiler AREA(l, b) in het programma vindt, deze deze vervangt door de instructie (l*b). Niet alleen dit, maar de waarden die aan de macrosjabloon AREA(l, b) worden doorgegeven, worden ook vervangen in de instructie (l*b). Daarom is AREA(10, 5) gelijk aan 10*5.
2. Bestandsopname
Dit type preprocessorrichtlijn vertelt de compiler dat hij een bestand in het broncodeprogramma moet opnemen. De #include preprocessor-richtlijn wordt gebruikt om de headerbestanden in het C-programma op te nemen.
Er zijn twee soorten bestanden die door de gebruiker in het programma kunnen worden opgenomen:
Standaard headerbestanden
De standaard headerbestanden bevatten definities van vooraf gedefinieerde functies zoals printf(), scanf(), etc. Deze bestanden moeten worden meegeleverd om met deze functies te kunnen werken. Verschillende functies worden gedeclareerd in verschillende headerbestanden.
Standaard I/O-functies bevinden zich bijvoorbeeld in het ‘iostream’-bestand, terwijl functies die stringbewerkingen uitvoeren zich in het ‘string’-bestand bevinden.
Syntaxis
#include < file_name>>
waar bestandsnaam is de naam van het headerbestand dat moet worden opgenomen. De ‘’ haakjes vertel de compiler om naar het bestand in de s standaard map.
Door de gebruiker gedefinieerde headerbestanden
Wanneer een programma erg groot wordt, is het een goede gewoonte om het in kleinere bestanden te verdelen en deze op te nemen wanneer dat nodig is. Dit soort bestanden zijn door de gebruiker gedefinieerde headerbestanden.
Syntaxis
#include ' filename '>
De dubbele aanhalingstekens ( ) vertel de compiler om te zoeken naar het headerbestand in de map van het bronbestand.
3. Voorwaardelijke compilatie
Voorwaardelijke compilatie in C-richtlijnen is een soort richtlijn die helpt bij het compileren van een specifiek deel van het programma of het overslaan van de compilatie van een specifiek deel van het programma op basis van bepaalde voorwaarden. Er zijn de volgende preprocessor-instructies die worden gebruikt om voorwaardelijke code in te voegen:
- #if Richtlijn
- #ifdef-richtlijn
- #ifndef-richtlijn
- #else richtlijn
- #elif-richtlijn
- #endif-richtlijn
#stop als richtlijn wordt gebruikt om de openingsrichtlijnen #if, #ifdef en #ifndef af te sluiten, wat betekent dat de voorverwerking van deze richtlijnen is voltooid.
Syntaxis
#ifdef macro_name // Code to be executed if macro_name is defined # ifndef macro_name // Code to be executed if macro_name is not defined #if constant_expr // Code to be executed if constant_expression is true #elif another_constant_expr // Code to be excuted if another_constant_expression is true #else // Code to be excuted if none of the above conditions are true #endif>
Als de macro met de naam ‘ macronaam ‘ is gedefinieerd, dan zal het blok met instructies normaal worden uitgevoerd, maar als het niet is gedefinieerd, zal de compiler dit blok met instructies eenvoudigweg overslaan.
Voorbeeld
Het onderstaande voorbeeld demonstreert het gebruik van de preprocessorrichtlijnen #include #if, #elif, #else en #endif.
C
//program to demonstrates the use of #if, #elif, #else,> // and #endif preprocessor directives.> #include> // defining PI> #define PI 3.14159> int> main()> {> > #ifdef PI> >printf>(>'PI is defined
'>);> > #elif defined(SQUARE)> >printf>(>'Square is defined
'>);> #else> >#error 'Neither PI nor SQUARE is defined'> #endif> > #ifndef SQUARE> >printf>(>'Square is not defined'>);> #else> >cout <<>'Square is defined'> << endl;> #endif> >return> 0;> }> |
Excel-datumverschil
>
>Uitvoer
PI is defined Square is not defined>
4. Overige richtlijnen
Naast de bovenstaande richtlijnen zijn er nog twee richtlijnen die niet vaak worden gebruikt. Dit zijn:
- #undef-richtlijn
- #pragma-richtlijn
1. #undef-richtlijn
De #undef-richtlijn wordt gebruikt om de definitie van een bestaande macro ongedaan te maken. Deze richtlijn werkt als:
#undef LIMIT>
Als u deze instructie gebruikt, wordt de definitie van de bestaande macro LIMIT ongedaan gemaakt. Na deze verklaring wordt elke #ifdef LIMIT-verklaring als onwaar beoordeeld.
Voorbeeld
Het onderstaande voorbeeld demonstreert de werking van #undef-richtlijn.
C
#include> // defining MIN_VALUE> #define MIN_VALUE 10> int> main() {> >// Undefining and redefining MIN_VALUE> printf>(>'Min value is: %d
'>,MIN_VALUE);> > //undefining max value> #undef MIN_VALUE> > // again redefining MIN_VALUE> #define MIN_VALUE 20> >printf>(>'Min value after undef and again redefining it: %d
'>, MIN_VALUE);> >return> 0;> }> |
>
>Uitvoer
Min value is: 10 Min value after undef and again redefining it: 20>
2. #pragma-richtlijn
Deze richtlijn is een richtlijn voor een speciaal doel en wordt gebruikt om bepaalde functies in of uit te schakelen. Dit soort richtlijnen zijn compilerspecifiek, dat wil zeggen dat ze variëren van compiler tot compiler.
Syntaxis
#pragma directive>
Enkele van de #pragma-richtlijnen worden hieronder besproken:
- #pragma opstarten: Deze richtlijnen helpen ons bij het specificeren van de functies die nodig zijn om te worden uitgevoerd vóór het opstarten van het programma (voordat de besturing overgaat naar main()).
- #pragma uitgang : Deze richtlijnen helpen ons de functies te specificeren die nodig zijn om te worden uitgevoerd vlak voordat het programma wordt afgesloten (net voordat het besturingselement terugkeert van main()).
Het onderstaande programma werkt niet met GCC-compilers.
Voorbeeld
Het onderstaande programma illustreer het gebruik van #pragma exit en pragma startup
C
// C program to illustrate the #pragma exit and pragma> // startup> #include> void> func1();> void> func2();> // specifying funct1 to execute at start> #pragma startup func1> // specifying funct2 to execute before end> #pragma exit func2> void> func1() {>printf>(>'Inside func1()
'>); }> void> func2() {>printf>(>'Inside func2()
'>); }> // driver code> int> main()> {> >void> func1();> >void> func2();> >printf>(>'Inside main()
'>);> >return> 0;> }> |
>
>
Verwachte resultaten
Inside func1() Inside main() Inside func2()>
De bovenstaande code produceert de uitvoer zoals hieronder weergegeven wanneer deze wordt uitgevoerd op GCC-compilers:
Inside main()c>
Dit gebeurt omdat GCC het opstarten of afsluiten van #pragma niet ondersteunt. U kunt de onderstaande code echter gebruiken voor de verwachte uitvoer op GCC-compilers.
C
#include> void> func1();> void> func2();> void> __attribute__((constructor)) func1();> void> __attribute__((destructor)) func2();> void> func1()> {> >printf>(>'Inside func1()
'>);> }> void> func2()> {> >printf>(>'Inside func2()
'>);> }> int> main()> {> >printf>(>'Inside main()
'>);> >return> 0;> }> |
>
>Uitvoer
Inside func1() Inside main() Inside func2()>
In het bovenstaande programma hebben we er enkele gebruikt specifieke syntaxis zodat een van de functies vóór de hoofdfunctie wordt uitgevoerd en de andere na de hoofdfunctie wordt uitgevoerd.
#pragma waarschuwt richtlijn
Deze richtlijn wordt gebruikt om het waarschuwingsbericht te verbergen dat wordt weergegeven tijdens het compileren. We kunnen de waarschuwingen verbergen zoals hieronder weergegeven:
- #pragma waarschuwen -rvl : Deze richtlijn verbergt de waarschuwingen die worden gegenereerd wanneer een functie die een waarde moet retourneren, geen waarde retourneert.
- #pragma waarschuwen -par : Deze richtlijn verbergt de waarschuwingen die worden gegenereerd wanneer een functie de parameters die eraan zijn doorgegeven niet gebruikt.
- #pragma waarschuwen -rch : Deze richtlijn verbergt de waarschuwingen die worden gegeven wanneer een code onbereikbaar is. Elke code die na de opbrengst statement in een functie is onbereikbaar.
Als u techcodeview.com leuk vindt en een bijdrage wilt leveren, kunt u ook een artikel schrijven met . Zie uw artikel verschijnen op de hoofdpagina van techcodeview.com en help andere Geeks. Schrijf opmerkingen als u iets onjuist vindt, of als u meer informatie wilt delen over het hierboven besproken onderwerp.