Preprocessorer er programmer, der behandler kildekoden før kompilering. Der er flere trin involveret mellem at skrive et program og at udføre et program i C. Lad os se på disse trin, før vi rent faktisk begynder at lære om Preprocessors.
Du kan se de mellemliggende trin i ovenstående diagram. Kildekoden skrevet af programmører gemmes først i en fil, lad navnet være program.c . Denne fil behandles derefter af præprocessorer, og en udvidet kildekodefil genereres med navnet program.i. Denne udvidede fil kompileres af compileren, og der genereres en objektkodefil med navnet program.obj. Endelig linker linkeren denne objektkodefil til objektkoden for biblioteksfunktionerne for at generere den eksekverbare fil program.exe.
Forbehandlerdirektiver i C
Preprocessor-programmer giver præprocessor-direktiver, der fortæller compileren at forbehandle kildekoden før kompilering. Alle disse præprocessor-direktiver begynder med et '#' (hash) symbol. '#'-symbolet angiver, at enhver sætning, der starter med et '#', vil gå til præprocessorprogrammet for at blive udført. Vi kan placere disse præprocessor-direktiver hvor som helst i vores program.
Eksempler på nogle præprocessor-direktiver er: #omfatte , #Definere , #ifndef, etc.
Bemærk Husk at # symbolet giver kun en sti til præprocessoren, og en kommando såsom include behandles af præprocessorprogrammet. For eksempel vil #include inkludere koden eller indholdet af den angivne fil i dit program.
Liste over præprocessor-direktiver i C
Følgende tabel viser alle præprocessor-direktiver i C:
| Forbehandlerdirektiver | Beskrivelse |
|---|---|
| #Definere | Bruges til at definere en makro |
| #undef | Bruges til at udefinere en makro |
| #omfatte | Bruges til at inkludere en fil i kildekodeprogrammet |
| #ifdef | Bruges til at inkludere en kodesektion, hvis en bestemt makro er defineret af #define |
| #ifndef | Bruges til at inkludere en kodesektion, hvis en bestemt makro ikke er defineret af #define |
| #hvis | Tjek for den angivne tilstand |
| #andet | Alternativ kode, der udføres, når #hvis fejler |
| #Afslut Hvis | Bruges til at markere slutningen af #if, #ifdef og #ifndef |
Disse præprocessorer kan klassificeres baseret på den type funktion, de udfører.
Typer af C-forprocessorer
Der er 4 hovedtyper af præprocessordirektiver:
- Makroer
- Filinkludering
- Betinget kompilering
- Andre direktiver
Lad os nu lære om hvert af disse direktiver i detaljer.
1. Makroer
I C er makroer stykker kode i et program, der får et eller andet navn. Når compileren støder på dette navn, erstatter compileren navnet med det faktiske kodestykke. Det '#Definere' direktiv bruges til at definere en makro.
Syntaks for makrodefinition
#define token value>
hvor efter forbehandling, den polet vil blive udvidet til sin værdi i programmet.
Eksempel 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 ovenstående program, når compileren udfører ordet LIMIT, erstatter den det med 5. Ordet 'BEGRÆNSE' i makrodefinitionen kaldes en makroskabelon og '5' er makroudvidelse.
Bemærk Der er intet semikolon (;) i slutningen af makrodefinitionen. Makrodefinitioner behøver ikke et semikolon for at slutte.
Der er også nogle Foruddefinerede makroer i C som er nyttige til at levere forskellige funktionaliteter til vores program.
Makroer med argumenter
Vi kan også overføre argumenter til makroer. Makroer defineret med argumenter fungerer på samme måde som funktioner.
Eksempel
#define foo( a, b ) a + b #define func(r) r * r>
Lad os forstå dette med et 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 fra ovenstående program, at når compileren finder AREA(l, b) i programmet, erstatter den det med sætningen (l*b). Ikke kun dette, men de værdier, der sendes til makroskabelonen AREA(l, b), vil også blive erstattet i sætningen (l*b). Derfor vil AREA(10, 5) være lig med 10*5.
2. Filinkludering
Denne type præprocessordirektiv fortæller compileren at inkludere en fil i kildekodeprogrammet. Det #include preprocessor direktiv bruges til at inkludere header-filerne i C-programmet.
Der er to typer filer, der kan inkluderes af brugeren i programmet:
Standard header-filer
Standard header-filerne indeholder definitioner af foruddefinerede funktioner som f.eks printf(), scanf(), osv. Disse filer skal inkluderes for at kunne arbejde med disse funktioner. Forskellige funktioner erklæres i forskellige header-filer.
For eksempel er standard I/O-funktioner i 'iostream'-filen, mens funktioner, der udfører strengoperationer, er i 'streng'-filen.
Syntaks
#include < file_name>>
hvor filnavn er navnet på den overskriftsfil, der skal inkluderes. Det '' beslag bed compileren om at lede efter filen i s tandard bibliotek.
Brugerdefinerede header-filer
Når et program bliver meget stort, er det en god praksis at opdele det i mindre filer og inkludere dem, når det er nødvendigt. Disse typer filer er brugerdefinerede header-filer.
Syntaks
#include ' filename '>
Det dobbelte anførselstegn ( ) bed compileren om at søge efter header-filen i kildefilens mappe.
3. Betinget kompilering
Betinget kompilering i C-direktiver er en type direktiv, der hjælper med at kompilere en specifik del af programmet eller at springe kompileringen af en bestemt del af programmet over baseret på nogle betingelser. Der er følgende præprocessor-direktiver, der bruges til at indsætte betinget kode:
- #if-direktivet
- #ifdef-direktivet
- #ifndef-direktivet
- #else direktiv
- #elif-direktivet
- #endif-direktivet
#Afslut Hvis direktiv bruges til at lukke #if, #ifdef og #ifndef åbningsdirektiverne, hvilket betyder, at forbehandlingen af disse direktiver er afsluttet.
Syntaks
#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>
Hvis makroen med navnet ' makro_navn ' er defineret, vil sætningsblokken køre normalt, men hvis den ikke er defineret, vil compileren simpelthen springe denne sætningsblok over.
Eksempel
Eksemplet nedenfor viser brugen af #include #if, #elif, #else og #endif preprocessor-direktiver.
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;> }> |
sqrt java matematik
>
>Produktion
PI is defined Square is not defined>
4. Andre direktiver
Ud over de ovennævnte direktiver er der yderligere to direktiver, som ikke er almindeligt anvendte. Disse er:
- #undef-direktivet
- #pragmadirektivet
1. #undef-direktiv
#undef-direktivet bruges til at udefinere en eksisterende makro. Dette direktiv fungerer som:
#undef LIMIT>
Brug af denne erklæring vil udefinere den eksisterende makro LIMIT. Efter denne erklæring vil hver #ifdef LIMIT-sætning evalueres som falsk.
Eksempel
Nedenstående eksempel viser, hvordan #undef-direktivet fungerer.
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
Dette direktiv er et direktiv med særlige formål og bruges til at slå nogle funktioner til eller fra. Disse typer af direktiver er compiler-specifikke, dvs. de varierer fra compiler til compiler.
Syntaks
#pragma directive>
Nogle af #pragma-direktiverne diskuteres nedenfor:
- #pragma opstart: Disse direktiver hjælper os med at specificere de funktioner, der er nødvendige for at køre før programstart (før styringen overføres til main()).
- #pragma exit : Disse direktiver hjælper os med at specificere de funktioner, der er nødvendige for at køre lige før programmet afsluttes (lige før kontrollen vender tilbage fra main()).
Nedenstående program vil ikke fungere med GCC-kompilere.
Eksempel
Nedenstående program illustrere brugen af #pragma exit og 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;> }> |
>
>
Forventet output
Inside func1() Inside main() Inside func2()>
Ovenstående kode vil producere output som angivet nedenfor, når det køres på GCC-kompilere:
Inside main()c>
Dette sker, fordi GCC ikke understøtter #pragma opstart eller exit. Du kan dog bruge nedenstående kode til det forventede output på GCC-kompilere.
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 ovenstående program har vi brugt nogle specifikke syntakser således at en af funktionerne udføres før hovedfunktionen og den anden udføres efter hovedfunktionen.
#pragma warn-direktivet
Dette direktiv bruges til at skjule advarselsmeddelelsen, som vises under kompilering. Vi kan skjule advarslerne som vist nedenfor:
- #pragma advare -rvl : Dette direktiv skjuler de advarsler, der opstår, når en funktion, der skal returnere en værdi, ikke returnerer en værdi.
- #pragma advare -par : Dette direktiv skjuler de advarsler, der bliver rejst, når en funktion ikke bruger de parametre, der er sendt til den.
- #pragma advare -rch : Dette direktiv skjuler de advarsler, der bliver rejst, når en kode ikke er tilgængelig. For eksempel enhver kode skrevet efter Vend tilbage sætning i en funktion er uopnåelig.
Hvis du kan lide techcodeview.com og gerne vil bidrage, kan du også skrive en artikel vha . Se din artikel, der vises på techcodeview.com-hovedsiden, og hjælp andre nørder. Skriv venligst kommentarer, hvis du finder noget forkert, eller hvis du vil dele flere oplysninger om emnet diskuteret ovenfor.