Meny

Forprosessordirektiver i C ++

preprocessor directives c

Prøv Instrumentet Vårt For Å Eliminere Problemer

En detaljert titt på forprosessordirektiver i C ++.

Forprosessoren er en unik funksjon i C ++. I C ++ har vi trinn som kompilering, kobling og utføring for et typisk program. I virkeligheten har vi mange andre funksjoner i et C ++ - program som må behandles før vi sender programmet til kompilering.

For dette formålet utføres et spesielt trinn som kalles forbehandling. Forbehandling utføres før kompileringsprosessen og spesialfunksjonene er forhåndsbehandlet. Som et resultat oppnås et utvidet C ++ - program, og deretter sendes det til kompilatoren.

=> Besøk her for å lære C ++ fra grunnen.

Forprosessordirektiver i C ++

Hva du vil lære:

Oversikt

Spesialfunksjonene for forhåndsbehandling identifiseres ved hjelp av en enhet kalt “Preprocessor directive”. Disse forprosessordirektivene forteller kompilatoren at viss informasjon i C ++ - programmet som er merket med forprosessordirektiv, må forhåndsbehandles før kompilering.

Merk at i C ++ begynner alle prosessordirektivene med et '#' -symbol. I det øyeblikket forprosessoren (en del av kompilatoren) møter # -symbolet, blir informasjonen etter # -symbolet forhåndsbehandlet før programmet sendes til kompilatoren.

I motsetning til de andre C ++ uttalelsene, slutter ikke prosessordirektivene med semikolon.

I denne opplæringen vil vi utforske de forskjellige forprosessordirektivene som støttes av C ++.

Direktiver for fil inkludering

#inkludere

Direktivet om fil inkludering #include lar oss inkludere andre filer i kildeprogrammet vårt. Vi kan inkludere hvilken som helst headerfil som inneholder definisjoner av forskjellige forhåndsdefinerte funksjoner i programmet vårt ved hjelp av disse funksjonene. Vi kan inkludere headerfiler i programmet vårt ved hjelp av følgende syntaks.

#include

Eksempel: #inkludere

Vi har allerede sett dette i C ++ - programmene våre. Toppteksten iostream inneholder funksjonene som kreves for inn- / utdatastreaming som cout, cin, etc.

Etter hvert som programmene våre blir større eller funksjonaliteten blir kompleks, vil vi kanskje dele programmet vårt i forskjellige filer eller importere funksjonalitet fra de andre filene. I dette tilfellet bruker vi brukerdefinerte filer. For å inkludere brukerdefinerte filer i programmet vårt, kan vi bruke følgende syntaks av #include-direktivet.

#include “filename”

Eksempel: # inkluderer 'vector_int.h'

Dette er en brukerdefinert toppfil som vi har tenkt å inkludere i programmet vårt for å kunne bruke funksjonaliteten.

Kodeeksemplet nedenfor viser bruken av #include-direktivet.

åpne jar-filer på Windows 10
#include using namespace std; int main() { cout<<'This is an example demonstrating inclusion directive #include'; }

Produksjon:

Dette er et eksempel som viser inkluderingsdirektivet #include.

Som vist har vi brukt #include-direktivet for å inkludere topptekstens funksjonalitet i programmet vårt.

Makrodefinisjonsdirektiver

#definere

#Define-direktivet brukes til å definere symbolske konstanter eller makroer i C ++ - programmet.

Den generelle formen for et #definerende direktiv er:

#define macro_name replacement code

Når en forprosessor møter makroen i programmet, erstatter forprosessoren denne makroen med koden som er definert ved hjelp av #definer-direktivet før koden sendes til kompilatoren.

Nedenfor kodeeksempel viser en symbolsk konstant RADIUS som er definert ved hjelp av #define-direktivet og dets bruk i programmet.

#include #define RADIUS 5 using namespace std; int main() { cout<<'Area of a circle : '<<3.142 * RADIUS * RADIUS; }

Produksjon:

Område av en sirkel: 78,55

Som vist i programmet kan vi bruke symbolsk konstant RADIUS i koden vår, og den vil bli erstattet av verdien definert for den ved hjelp av #define-direktivet.

beste gratis sikkerhetskopiprogramvare for mac

Vi kan bruke #define-direktivet til å definere en riktig funksjonskode. Disse funksjonene er vanligvis små funksjoner.

Et eksempel er vist nedenfor.

#include #define REC_AREA(length, breadth) (length * breadth) using namespace std; int main() { int length = 20, breadth = 5, area; area = REC_AREA(length, breadth); cout << 'Area of a rectangle is: ' << area; return 0; }

Produksjon:

Arealet av et rektangel er: 100

Her ved hjelp av #define-direktivet har vi definert en funksjon REC_AREA som tar to argumenter, dvs. lengde og bredde og beregner arealet til et rektangel. I hovedfunksjonen bruker vi bare denne makroen og leverer to argumenter til den for å oppnå arealet til et rektangel.

#undef

Makroer i et program definert med #define-direktivet varer til det er udefinert ved hjelp av #undef-direktivet. Når programmet møter #undef, vil den påfølgende bruken av makro (udefinert av #undef) gi en kompileringsfeil.

I det ovennevnte programmet, hvis vi bare gir en uttalelse #undef REC_AREA etter heltallsdeklarasjonene, vil programmet gi en kompileringsfeil.

Direktiv om betinget kompilering

Bortsett fra direktivene som er forklart ovenfor, gir C ++ også følgende direktiver som kan brukes til betinget kompilering av kode. Disse direktivene kan brukes på lignende linjer i if-else-setningen til C ++.

For eksempel, Vi kan sette DEBUG for et program PÅ eller AV ved hjelp av disse betingede retningslinjene.

Noen av de betingede kompileringsdirektivene gitt i C ++ inkluderer:

  • #hvis
  • #elif
  • #slutt om
  • #ifdef
  • #ifndef
  • #ellers

Programmet nedenfor viser bruken av betingede kompileringsdirektiver i et C ++ - program.

#include using namespace std; #define DEBUG #define MAX(a,b) (((a)>(b)) ? a : b) int main () { int i, j; i = 100; j = 50; #ifdef DEBUG cout <<'Trace: Start of main function' << endl; #endif cout <<'The maximum is ' << MAX(i, j) << endl; #undef MAX //cout <<'The maximum is ' << MAX(10,20) << endl; #ifdef DEBUG cout <<'Trace: End of main function' << endl; #endif return 0; }

Produksjon:

Spor: Start av hovedfunksjon
Maksimum er 100
Spor: Slutt på hovedfunksjonen

I programmet ovenfor bruker vi #ifdef - #endif-direktivet for å definere en DEBUG for programmet. Da definerte vi makrofunksjonen MAX ved hjelp av #undef-direktivet. Direktivet om betinget kompilering konstruerer #ifdef - #endif sjekker om DEBUG er satt, og hvis det er satt, skriver det ut få meldinger i programmet.

Operatørene # & ##

Operatorene # og ## er to spesialoperatorer som brukes til å konvertere et teksttoken til en streng som skal vises og sammenkoble to tokens.

Nedenfor er gitt et eksempel som demonstrerer begge disse operatørene.

#include using namespace std; #define MKSTR( x ) #x #define concat(a, b) a ## b int main () { cout <<'MKSTR(Hello World) = '<< MKSTR(Hello World) << endl; int xy = 100; cout <<'concat(x,y) = '<

Produksjon:

MKSTR (Hello World) = Hello World
konkat (x, y) = 100

I programmet ovenfor definerer vi MKSTR med et argument x. Den har kropp #x. Når vi skriver ut denne MKSTR ved hjelp av argumentet “Hello World”, ser vi at på grunn av #x blir argumentet konvertert til en streng og vises til utdataene.

Deretter har vi definert en konkatfunksjon med to argumenter a og b. I kroppen spesifiserer vi en ## b. Uttrykk a ## b tilsvarer ab. Dermed i hovedfunksjonen når vi kaller concat (x, y), evalueres den faktisk til xy som er lik heltallvariabelen som vi definerte.

Andre direktiver

#feil

Den generelle syntaksen til #error-direktivet er:

#error error_message

Når kompilatoren møter #error-direktivet, vises feilmeldingen og kompilering stopper. Argumentet error_message kan inneholde ett eller flere ord med eller uten anførselstegn.

#linje

Dette ber kompilatoren om å endre kompilatorens internt lagrede linjenummer og filnavn til gitt linjenummer og filnavn.

#linje siffer-sekvens (“filnavn”)

Siftsekvensen kan være en heltallskonstant.

Eksempel:#line 200 test.c

I eksemplet ovenfor er det internt lagrede linjenummeret satt til 200, og filnavnet endres til test.c.

#pragma

Leverer implementeringsdefinerte instruksjoner til kompilatoren. Disse instruksjonene er spesifikke for kompilatoren og plattformen. Hvis instruksjonen ikke stemmer overens, blir direktivet ignorert uten å generere en syntaksfeil.

Forhåndsdefinerte makroer

C ++ definerer også en rekke forhåndsdefinerte makroer som kan brukes av programmererne.

Noen av disse makroene er tabellert nedenfor.

Forhåndsdefinert makroBeskrivelse
__FIL__Det nåværende filnavnet til programmet som kompileres
__DATO__Dato for oversettelse av kildekode til objektkode i formatet måned / dag / år
__TID__Tid i skjemaet time: minutt: sekund hvor programmet kompileres
__LINJE__Gjeldende linjenummer for programmet som kompileres
__cplusplusHeltallskonstant som er definert for hver kompilatorversjon

Følgende program demonstrerer disse makroene i et program.

#include using namespace std; int main () { cout<<'__LINE__ :' << __LINE__ << endl; cout<<'__FILE__ :' << __FILE__ << endl; cout<<'__DATE__ :' << __DATE__ << endl; cout<<'__TIME__ :' << __TIME__ << endl; cout<<'__cplusplus:'<<__cplusplus<

Produksjon:

__LINE__: 5
__FIL__: prog.cpp
__DATE__: 15. april 2019
__TID__: 12: 09: 15
__cplusplus: 201402

Programutgangen ovenfor er i tråd med forklaringen på de forhåndsdefinerte makroene ovenfor og er selvforklarende.

Konklusjon

I denne opplæringen har vi sett forskjellige preprosessor-direktiver levert av C ++ sammen med eksemplene deres. Preprocessor-direktiver hjelper oss til å skrive mer effektive programmer og mer lesbare programmer til en viss grad.

c ++ innføringssorteringsalgoritme

Direktivene om betinget kompilering tillater oss også å forgrense programutgangen vår på forskjellige måter.

=> Se etter hele C ++ treningsserien her.

Anbefalt lesing

^