Menu

Preprocessor-richtlijnen in C ++

preprocessor directives c

Probeer Ons Instrument Voor Het Oplossen Van Problemen

Een gedetailleerde kijk op Preprocessor-richtlijnen in C ++.

De preprocessor is een uniek kenmerk van C ++. In C ++ hebben we stappen zoals compilatie, koppeling en uitvoering voor een typisch programma. In werkelijkheid hebben we veel andere functies in een C ++ -programma die moeten worden verwerkt voordat het programma voor compilatie doorstaat.

Voor dit doel wordt een speciale stap, genaamd voorverwerking, uitgevoerd. De voorverwerking wordt uitgevoerd voordat het compilatieproces plaatsvindt en de speciale functies worden voorbewerkt. Als resultaat wordt een uitgebreid C ++ -programma verkregen en vervolgens doorgegeven aan de compiler.

​ Bezoek hier om C ++ vanaf het begin te leren.

Preprocessor-richtlijnen in C ++

Wat je leert:

Overzicht

De speciale functies voor voorverwerking worden geïdentificeerd met behulp van een entiteit genaamd 'Preprocessor-richtlijn'. Deze preprocessorrichtlijnen vertellen de compiler dat bepaalde informatie in het C ++ -programma gemarkeerd met preprocessorrichtlijnen moet worden voorbewerkt voordat het compileren.

Merk op dat in C ++ alle preprocessor-instructies beginnen met een '#' -symbool. Op het moment dat de preprocessor (onderdeel van de compiler) het # -symbool tegenkomt, wordt de informatie na het # -symbool voorbewerkt voordat het programma aan de compiler wordt doorgegeven.

In tegenstelling tot de andere C ++ -instructies eindigen preprocessorrichtlijnen niet met een puntkomma.

In deze tutorial zullen we de verschillende preprocessor-richtlijnen onderzoeken die worden ondersteund door C ++.

Richtlijnen voor bestandsopname

#inclusief

Bestandsopname-instructie #include stelt ons in staat om andere bestanden in ons bronprogramma op te nemen. We kunnen elk header-bestand dat definities van verschillende vooraf gedefinieerde functies bevat in ons programma opnemen met behulp van deze functies. We kunnen header-bestanden in ons programma opnemen met behulp van de volgende syntaxis.

​

Voorbeeld: #inclusief

We hebben dit al gezien in onze C ++ -programma's. De header iostream bevat de functies die nodig zijn voor input / output datastreaming zoals cout, cin, etc.

Naarmate onze programma's groter worden of de functionaliteit complexer wordt, willen we ons programma misschien opdelen in verschillende bestanden of functionaliteit importeren vanuit de andere bestanden. In dit geval maken we gebruik van door de gebruiker gedefinieerde bestanden. Om door de gebruiker gedefinieerde bestanden in ons programma op te nemen, kunnen we gebruik maken van de volgende syntaxis van # include-richtlijn.

​

Voorbeeld: # include “vector_int.h”

Dit is een door de gebruiker gedefinieerd header-bestand dat we in ons programma willen opnemen om de functionaliteit ervan te gebruiken.

Het onderstaande codevoorbeeld toont het gebruik van de # include-richtlijn.

breedte eerste traversal c ++
​

Uitgang:

Dit is een voorbeeld dat de insluitingsrichtlijn #include laat zien.

Zoals getoond hebben we de #include-richtlijn gebruikt om de functionaliteit van de header in ons programma op te nemen.

Richtlijnen voor macrodefinitie

#bepalen

De #define-instructie wordt gebruikt om de symbolische constanten of macro's in het C ++ -programma te definiëren.

De algemene vorm van een #define-richtlijn is:

​

Wanneer een preprocessor de macro in het programma tegenkomt, vervangt de preprocessor deze macro door de code die is gedefinieerd met behulp van de #define-richtlijn voordat de code wordt doorgegeven aan de compiler.

Het onderstaande codevoorbeeld toont een symbolische constante RADIUS die is gedefinieerd met de #define-richtlijn en het gebruik ervan in het programma.

​

Uitgang:

Oppervlakte van een cirkel: 78.55

Zoals getoond in het programma, kunnen we gebruik maken van de symbolische constante RADIUS in onze code en deze zal worden vervangen door de waarde die ervoor is gedefinieerd met behulp van de #define-richtlijn.

hoe json-bestand te openen in android

We kunnen de #define-richtlijn gebruiken om een ​​juiste functiecode te definiëren. Deze functies zijn meestal kleine functies.

Hieronder ziet u een voorbeeld.

​

Uitgang:

De oppervlakte van een rechthoek is: 100

Hier hebben we met behulp van de #define-richtlijn een functie REC_AREA gedefinieerd die twee argumenten accepteert, d.w.z. lengte en breedte, en de oppervlakte van een rechthoek berekent. In de hoofdfunctie maken we gewoon gebruik van deze macro en geven we er twee argumenten aan om de oppervlakte van een rechthoek te verkrijgen.

#undef

Macro's in een programma dat is gedefinieerd met de #define-richtlijn, duren tot het ongedefinieerd is met de #undef-richtlijn. Zodra het programma #undef tegenkomt, zal het daaropvolgende gebruik van macro (niet gedefinieerd door #undef) een compilatiefout geven.

Als we in het bovenstaande programma alleen een statement #undef REC_AREA geven na de integer-declaraties, geeft het programma een compilatiefout.

Richtlijnen voor voorwaardelijke samenstelling

Afgezien van de hierboven toegelichte richtlijnen, biedt C ++ ook de volgende richtlijnen die kunnen worden gebruikt voor voorwaardelijke compilatie van code. Deze richtlijnen kunnen worden gebruikt op vergelijkbare regels van de if-else-instructie van C ++.

Bijvoorbeeld, we kunnen DEBUG voor een programma AAN of UIT zetten met behulp van deze voorwaardelijke richtlijnen.

Enkele van de voorwaardelijke compilatierichtlijnen in C ++ zijn onder meer:

  • #als
  • #elif
  • #stop als
  • #ifdef
  • #ifndef
  • #anders

Het onderstaande programma demonstreert het gebruik van voorwaardelijke compilatierichtlijnen in een C ++ -programma.

​

Uitgang:

Trace: begin van de hoofdfunctie
Het maximum is 100
Trace: einde van de hoofdfunctie

In het bovenstaande programma gebruiken we de richtlijn #ifdef - #endif om een ​​DEBUG voor het programma te definiëren. Vervolgens hebben we de macrofunctie MAX ongedefinieerd met behulp van de #undef-richtlijn. De voorwaardelijke compilatierichtlijn construeert #ifdef - #endif controleert of DEBUG is ingesteld en als deze is ingesteld, worden enkele berichten in het programma afgedrukt.

De # & ## operators

De operators # en ## zijn twee speciale operators die respectievelijk worden gebruikt om een ​​teksttoken om te zetten in een tekenreeks die moet worden weergegeven en om twee tokens aaneen te schakelen.

Hieronder wordt een voorbeeld gegeven dat beide operators laat zien.

​

Uitgang:

MKSTR (Hallo wereld) = Hallo wereld
concat (x, y) = 100

In het bovenstaande programma definiëren we MKSTR met een argument x. Het heeft body #x. Als we deze MKSTR afdrukken met het argument 'Hallo wereld', zien we dat vanwege #x het argument wordt geconverteerd naar een string en wordt weergegeven aan de uitvoer.

Vervolgens hebben we een concat-functie gedefinieerd met twee argumenten a en b. In de body specificeren we a ## b. Uitdrukking a ## b is gelijk aan ab. Dus in de hoofdfunctie wanneer we concat (x, y) aanroepen, evalueert het feitelijk naar xy, wat gelijk is aan de integer-variabele die we hebben gedefinieerd.

Andere richtlijnen

#fout

De algemene syntaxis van de #error-richtlijn is:

de primaire toegangsrechten voor bestanden in unix zijn:
​

Wanneer de compiler de #error-instructie tegenkomt, wordt de error_message weergegeven en stopt de compilatie. Het argument error_message kan een of meer woorden met of zonder aanhalingstekens bevatten.

#lijn

Dit vertelt de compiler om het intern opgeslagen regelnummer en de bestandsnaam van de compiler te veranderen in het opgegeven regelnummer en de bestandsnaam.

#lijn cijferreeks ('bestandsnaam')

De cijferreeks kan een constante van een geheel getal zijn.

Voorbeeld:# lijn 200-test. c

In het bovenstaande voorbeeld is het intern opgeslagen regelnummer ingesteld op 200 en wordt de bestandsnaam gewijzigd in test.c.

#pragma

Levert implementatie-gedefinieerde instructies aan de compiler. Deze instructies zijn specifiek voor de compiler en het platform. Als de instructie niet overeenkomt, wordt de instructie genegeerd zonder een syntaxisfout te genereren.

Vooraf gedefinieerde macro's

C ++ definieert ook talrijke vooraf gedefinieerde macro's die door de programmeurs kunnen worden gebruikt.

Enkele van deze macro's worden hieronder in tabelvorm weergegeven.

Vooraf gedefinieerde macroOmschrijving
__HET DOSSIER__De huidige bestandsnaam van het programma dat wordt gecompileerd
__DATUM__Datum van vertaling van broncode naar objectcode in het formaat maand / dag / jaar
__TIJD__Tijd in de vorm uur: minuut: seconde waarop het programma wordt samengesteld
__LIJN__Het huidige regelnummer van het programma dat wordt gecompileerd
__cplusplusInteger-constante die is gedefinieerd voor elke compilerversie

Het volgende programma demonstreert deze macro's in een programma.

​

Uitgang:

__LINE__: 5
__BESTAND__: prog.cpp
__DATE__: 15 april 2019
__TIME__: 12: 09: 15
__cplusplus: 201402

De bovenstaande programma-uitvoer is in lijn met de uitleg van de vooraf gedefinieerde macro's hierboven en spreekt voor zich.

Gevolgtrekking

In deze tutorial hebben we verschillende preprocessor-richtlijnen gezien die door C ++ zijn geleverd, samen met hun voorbeelden. Preprocessor-richtlijnen helpen ons tot op zekere hoogte efficiëntere programma's en beter leesbare programma's te schrijven.

De voorwaardelijke compilatierichtlijnen stellen ons ook in staat om onze programma-uitvoer op verschillende manieren te vertakken.

​ Zoek hier de volledige C ++-trainingsserie.

Aanbevolen literatuur

^