Inleiding tot Preprocessor-richtlijnen in C
Meestal wordt het gemaakt als een misvatting dat Preprocessors of macro's deel uitmaken van de compilatie van het programma, maar het is helemaal verkeerd. Preprocessor-richtlijnen zijn het type macro's en een fase voordat compilatie plaatsvindt. Er kan worden gezegd dat dit enkele instructies zijn die aan de compiler worden gegeven om de daadwerkelijke compilatie uit te voeren. Ze staan ook bekend als langere construct-afkortingen voor macro's, wat betekent dat de waarde in macro's wordt vervangen door het codesegment. Macro wordt gedefinieerd door een speciaal symbool en heeft een symbool dat begint met "#". Daarom is deze # define een soort speciale preprocessor gevolgd door de eigenlijke compiler. In dit onderwerp gaan we meer te weten komen over Preprocessor-richtlijnen in C.
De preprocessor heeft een speciaal type weergave voor zijn identificatie zoals elke preprocessorrichtlijn zichzelf initieert door een speciaal symbool van "#" gevolgd door een ID en vervolgens de naam van de richtlijn. Witruimte is ook toegestaan voor en na de #. Bijvoorbeeld, # include.
Er zijn bepaalde aanvallen of voorzieningen die een C Preprocessor kan bieden:
- Koptekstbestanden: opname van koptekstbestanden is een manier waarop declaraties kunnen worden vervangen door de syntaxis van het programma en de hoofdtekst van het programma.
- Macro uitbreiden: het definiëren van macro's is als het inkorten van een stuk code dat een C-preprocessor de macro's overal vervangt met hun respectieve definitie.
- Compilatie door voorwaarden: volgens verschillende scenario's of verschillende voorwaarden is opname van bepaalde delen van het programma mogelijk door voorwaardelijke compilatie.
- Lijnbesturing: als u een programma gebruikt om iemand of meer bronbestanden te combineren of te herschikken in een tussenbestand voor compilatie, kunt u lijnbesturing gebruiken om de compiler te informeren waar elke bronlijn vandaan komt.
Soorten Preprocessor-richtlijnen
Alle soorten Preprocessor-richtlijnen zijn als volgt:
- # definiëren
- # include
- # ifdef
- # undef
- #ifndef
- # als
- #anders
- #elif
- #stop als
- #fout
- #pragma
1. #define (macro's)
Een macro is een codefragment dat wordt vervangen door een bepaalde waarde van de macrocode. Elke macro wordt meestal beschreven en gedefinieerd door de #define-richtlijn.
Syntaxis:
#define token value
Er zijn twee soorten macro's:
- Functie - zoals macro's
- Objectachtige macro's
Functie - zoals macro's
De functie like-macro werkt bijna als een functieaanroep.
Bijvoorbeeld:
#define MAX(a, b) ((a)>(b) ? (a): (b))
MAX hier is de macronaam.
Voorbeeld:
Output:
Objectachtige macro's
Objectachtige macro's zijn het type ID dat wordt vervangen door waarde. Het wordt meestal gebruikt om numerieke constanten weer te geven.
#define PI 3.1415
Hier wordt de waarde van PI vervangen door de macro.
Output:
2. # opnemen
Er is nog een andere functionaliteit voor de include preprocessor-richtlijn. Het heeft zijn eigen drie varianten die de code vervangen door de huidige bronbestanden.
Drie varianten zijn als volgt:
- #include
- # include”bestand”
- Neem nog iets anders op
#include
Zoekt naar een bestand in de gedefinieerde lijst van het systeem of de mappen zoals gespecificeerd en zoekt vervolgens naar een standaardlijst van systeembibliotheken.
# include”bestand”
Dit type wordt gebruikt voor uw eigen aangepaste header-bestanden van het programma. Er wordt eerst naar een bestand met de naam bestand in de huidige map gezocht, gevolgd door systeemkopbestanden en huidige mappen van het huidige mapbestand.
# omvatten alles
Dit type include-preprocessorrichtlijn wordt gebruikt wanneer geen van de andere twee resterende typen van de richtlijn en de argumenten niet passen en voldoen aan de berekeningsstructuur.
3. #Ifdef
Controleert of de macro wordt gedefinieerd door # definieer of niet. Zo ja, dan wordt de code uitgevoerd, anders niet.
Syntaxis:
#ifdef MACRO
(
Code body
)
#endif
#undef:
Als u de definitie van een macro wilt annuleren, betekent dit dat deze niet is gedefinieerd en wordt voorafgegaan door #undef-richtlijn.
Syntaxis:
#undef token
Output:
4. Ifndef
Deze processor controleert of #define al dan niet wordt gedefinieerd door #define. Zo ja, dan wordt de code uitgevoerd.
Syntaxis:
#Ifndef MACRO
//code
#endif
#If
Deze processor werkt alleen als een if-lus en evalueert de uitdrukking of voorwaarde. Als voorwaarde id waar is, wordt de code anders uitgevoerd.
Syntaxis:
#if expression
//code
#endif
#else
De #else preprocessorrichtlijn wordt gebruikt om de uitdrukking of voorwaarde te evalueren als de voorwaarde van #if onwaar is. Het kan worden gebruikt met de richtlijnen #if, #elif, #ifdef en #ifndef.
Syntaxis:
#if expression
//if body
#else
//else body
#endif
Voorbeeld:
Output:
5. #Fout
Zoals de naam al doet vermoeden, wordt de foutvoorbereidingsrichtlijn gebruikt om een fout aan te geven en geeft de compiler een fatale fout als er een foutrichtlijn wordt gevonden en worden de volgende compilatiestappen overgeslagen.
Output:
6. #pragma
Het hangt af van de compiler, omdat verschillende besturingssystemen en verschillende machines alle typen besturingssysteemfuncties bieden die door de compiler worden gebruikt om extra informatie aan de compiler te bieden.
Syntaxis:
#pragma token
Voorbeeld:
Output:
Elke Preprocessor heeft zijn eigen betekenis, zoals voorwaardelijke richtlijnen die worden gebruikt om te controleren of een deel van het programma in aanmerking moet worden genomen op basis van scenario's of niet.
Stel dat een programma in een specifieke omgeving met de specifieke configuratie van het besturingssysteem wil worden gecompileerd, maar zodra het naar die fase van compilatie gaat, geeft het een fout of geeft het een ongeldige code die alleen het programma de mogelijkheid geeft een grote nee om het programma te koppelen en uit te voeren tijdens het uitvoeren. Er kan ook een andere mogelijkheid zijn waarbij hetzelfde bronbestand met twee verschillende programma's een tijdrovende consistentiecontrole of de onmiddellijke gegevens kan uitvoeren, of de waarden van gegevens afdrukt met foutopsporing.
Ook kunnen deze scenario's die met berekening worden gemaakt, ook worden gebruikt om op één machine te worden uitgevoerd met behulp van preprocessing-richtlijnen.
Conclusie
De uitvoer van de C Preprocessor lijkt veel op de invoer, behalve dat alle voorbewerkingsrichtlijnen zijn vervangen door lege regels of witruimten. Verschillende bestanden en indelingen hebben verschillende syntaxis die zeggen dat de start van een nieuw bestand is gemaakt of dat een terugkeer naar een bestand of verwerking wordt aangegeven vóór compilatie.
Alle scenario's worden gebruikt om anderen de kracht van C-preprocessor te laten weten en hoe deze evolueert met verschillende versies van de compiler die zijn gestart met GCC- en ANSI-normen.
Aanbevolen artikelen
Dit is een gids voor Preprocessor-richtlijnen in C. Hier bespreken we de soorten Preprocessor-richtlijnen met syntaxis en voorbeelden. U kunt ook een kijkje nemen in de volgende artikelen voor meer informatie-
- Omgekeerd nummer in C
- Sorteren in C
- Hashing-functie in C
- Vervolg Verklaring in C
- Sorteren in C #
- Hoe werkt de hashing-functie in php?