Förprocessorer är program som bearbetar källkoden före kompilering. Flera steg är involverade mellan att skriva ett program och köra ett program i C. Låt oss ta en titt på dessa steg innan vi faktiskt börjar lära oss om Preprocessors.
Du kan se de mellanliggande stegen i diagrammet ovan. Källkoden som är skriven av programmerare lagras först i en fil, låt namnet vara program.c . Denna fil bearbetas sedan av förprocessorer och en utökad källkodsfil genereras med namnet program.i. Denna utökade fil kompileras av kompilatorn och en objektkodfil genereras med namnet program.obj. Slutligen länkar länken denna objektkodfil till objektkoden för biblioteksfunktionerna för att generera den körbara filen program.exe.
Förbearbetningsdirektiven i C
Förprocessorprogram tillhandahåller förprocessordirektiv som säger åt kompilatorn att förbehandla källkoden innan kompilering. Alla dessa förprocessordirektiv börjar med en '#' (hash)-symbol. '#'-symbolen indikerar att vilken sats som än börjar med ett '#' kommer att gå till förprocessorprogrammet för att köras. Vi kan placera dessa förbearbetningsdirektiv var som helst i vårt program.
Exempel på några förbearbetningsdirektiv är: #omfatta , #definiera , #ifndef, etc.
Notera Kom ihåg att # symbolen tillhandahåller endast en sökväg till förprocessorn, och ett kommando såsom include bearbetas av förprocessorprogrammet. Till exempel kommer #include att inkludera koden eller innehållet i den angivna filen i ditt program.
Lista över förbearbetningsdirektiv i C
Följande tabell listar alla förprocessordirektiv i C:
| Förbearbetningsdirektiv | Beskrivning |
|---|---|
| #definiera | Används för att definiera ett makro |
| #undef | Används för att avdefiniera ett makro |
| #omfatta | Används för att inkludera en fil i källkodsprogrammet |
| #ifdef | Används för att inkludera en kodsektion om ett visst makro definieras av #define |
| #ifndef | Används för att inkludera en kodsektion om ett visst makro inte definieras av #define |
| #om | Kontrollera det angivna tillståndet |
| #annan | Alternativ kod som körs när #if misslyckas |
| #endif | Används för att markera slutet på #if, #ifdef och #ifndef |
Dessa förprocessorer kan klassificeras baserat på vilken typ av funktion de utför.
Typer av C-förprocessorer
Det finns fyra huvudtyper av förbearbetningsdirektiv:
- Makron
- Filinkludering
- Villkorlig sammanställning
- Andra direktiv
Låt oss nu lära oss om vart och ett av dessa direktiv i detalj.
1. Makron
I C är makron kodbitar i ett program som får något namn. Närhelst detta namn påträffas av kompilatorn, ersätter kompilatorn namnet med den faktiska kodbiten. De '#definiera' direktiv används för att definiera ett makro.
Syntax för makrodefinition
#define token value>
där efter förbearbetning, den tecken kommer att utökas till sin värde i programmet.
Exempel på makro
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; }> |
>
>Produktion
0 1 2 3 4>
I programmet ovan, när kompilatorn kör ordet LIMIT, ersätter den det med 5. Ordet 'BEGRÄNSA' i makrodefinitionen kallas en makromall och '5' är makroexpansion.
Notera Det finns inget semikolon (;) i slutet av makrodefinitionen. Makrodefinitioner behöver inte ett semikolon för att sluta.
Det finns också några Fördefinierade makron i C som är användbara för att tillhandahålla olika funktioner till vårt program.
Makron Med Argument
Vi kan också skicka argument till makron. Makron som definieras med argument fungerar på samma sätt som funktioner.
Exempel
#define foo( a, b ) a + b #define func(r) r * r>
Låt oss förstå detta med ett program:
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;> }> |
>
>Produktion
Area of rectangle is: 50>
Vi kan se från ovanstående program att när kompilatorn hittar AREA(l, b) i programmet, ersätter den det med satsen (l*b). Inte bara detta, utan de värden som skickas till makromallen AREA(l, b) kommer också att ersättas i satsen (l*b). Därför blir AREA(10, 5) lika med 10*5.
2. Filinkludering
Denna typ av förprocessordirektiv säger åt kompilatorn att inkludera en fil i källkodsprogrammet. De #include preprocessor-direktiv används för att inkludera rubrikfilerna i C-programmet.
Det finns två typer av filer som kan inkluderas av användaren i programmet:
Standardhuvudfiler
Standardhuvudfilerna innehåller definitioner av fördefinierade funktioner som printf(), scanf(), etc. Dessa filer måste inkluderas för att fungera med dessa funktioner. Olika funktioner deklareras i olika rubrikfiler.
Till exempel finns standard I/O-funktioner i 'iostream'-filen medan funktioner som utför strängoperationer finns i 'sträng'-filen.
Syntax
#include < file_name>>
var filnamn är namnet på rubrikfilen som ska inkluderas. De '' parenteser säg till kompilatorn att leta efter filen i s tandard katalog.
Användardefinierade huvudfiler
När ett program blir mycket stort är det bra att dela upp det i mindre filer och ta med dem när det behövs. Dessa typer av filer är användardefinierade rubrikfiler.
Syntax
#include ' filename '>
De dubbla citattecken ( ) säg till kompilatorn att söka efter header-filen i källfilens katalog.
3. Villkorlig sammanställning
Villkorlig sammanställning i C-direktiv är en typ av direktiv som hjälper till att kompilera en specifik del av programmet eller att hoppa över kompileringen av någon specifik del av programmet baserat på vissa förutsättningar. Det finns följande förprocessordirektiv som används för att infoga villkorlig kod:
- #if-direktivet
- #ifdef-direktivet
- #ifndef-direktivet
- #else direktiv
- #elif-direktivet
- #endif-direktivet
#endif direktiv används för att stänga av öppningsdirektiven #if, #ifdef och #ifndef vilket innebär att förbehandlingen av dessa direktiv är klar.
Syntax
#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>
Om makrot med namnet makronamn ' är definierad, kommer blocket med satser att köras normalt, men om det inte är definierat kommer kompilatorn helt enkelt att hoppa över detta satsblock.
Exempel
Exemplet nedan visar användningen av #include #if, #elif, #else och #endif förprocessordirektiv.
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;> }> |
hoppa över listan
>
>Produktion
PI is defined Square is not defined>
4. Andra direktiv
Förutom ovanstående direktiv finns det ytterligare två direktiv som inte är vanligt förekommande. Dessa är:
- #undef-direktivet
- #pragmadirektivet
1. #undef-direktivet
#undef-direktivet används för att odefiniera ett befintligt makro. Detta direktiv fungerar som:
#undef LIMIT>
Användning av denna sats kommer att odefiniera det befintliga makrot LIMIT. Efter detta uttalande kommer varje #ifdef LIMIT-sats att utvärderas som falskt.
Exempel
Exemplet nedan visar hur #undef-direktivet fungerar.
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;> }> |
>
>Produktion
Min value is: 10 Min value after undef and again redefining it: 20>
2. #pragmadirektivet
Detta direktiv är ett specialdirektiv och används för att slå på eller stänga av vissa funktioner. Dessa typer av direktiv är kompilatorspecifika, det vill säga de varierar från kompilator till kompilator.
Syntax
#pragma directive>
Några av #pragma-direktiven diskuteras nedan:
- #pragma startup: Dessa direktiv hjälper oss att specificera de funktioner som behövs för att köras innan programmet startar (innan kontrollen går över till main()).
- #pragma utgång : Dessa direktiv hjälper oss att specificera de funktioner som behövs för att köras precis innan programmet avslutas (precis innan kontrollen återvänder från main()).
Nedanstående program fungerar inte med GCC-kompilatorer.
Exempel
Nedanstående program illustrera användningen av #pragma exit och 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;> }> |
>
>
Förväntad utgång
Inside func1() Inside main() Inside func2()>
Ovanstående kod kommer att producera utdata enligt nedan när den körs på GCC-kompilatorer:
Inside main()c>
Detta händer eftersom GCC inte stöder #pragma start eller exit. Du kan dock använda koden nedan för den förväntade utdata på GCC-kompilatorer.
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;> }> |
>
>Produktion
Inside func1() Inside main() Inside func2()>
I programmet ovan har vi använt några specifika syntaxer så att en av funktionerna körs före huvudfunktionen och den andra körs efter huvudfunktionen.
#pragma warn-direktivet
Detta direktiv används för att dölja varningsmeddelandet som visas under kompileringen. Vi kan dölja varningarna enligt nedan:
- #pragma varna -rvl : Detta direktiv döljer de varningar som visas när en funktion som ska returnera ett värde inte returnerar ett värde.
- #pragma varna -par : Detta direktiv döljer de varningar som visas när en funktion inte använder parametrarna som skickas till den.
- #pragma varna -rch : Detta direktiv döljer de varningar som visas när en kod inte går att nå. Till exempel, vilken kod som helst som skrivits efter lämna tillbaka uttalandet i en funktion är oåtkomligt.
Om du gillar techcodeview.com och vill bidra kan du också skriva en artikel med hjälp av . Se din artikel som visas på techcodeview.com huvudsida och hjälp andra nördar. Skriv kommentarer om du hittar något felaktigt eller om du vill dela mer information om ämnet som diskuterats ovan.