Meny

Förprocessordirektiv i C ++

preprocessor directives c

Prova Vårt Instrument För Att Eliminera Problem

En detaljerad titt på förprocessordirektiv i C ++.

Förprocessorn är en unik funktion i C ++. I C ++ har vi steg som kompilering, länkning och körning för ett typiskt program. I verkligheten har vi många andra funktioner i ett C ++ - program som behöver bearbetas innan vi skickar programmet för kompilering.

För detta ändamål genomförs ett speciellt steg som kallas förbehandling. Förbehandlingen utförs innan kompileringsprocessen och specialfunktionerna förbehandlas. Som ett resultat erhålls ett utökat C ++ - program och sedan skickas det till kompilatorn.

=> Besök här för att lära dig C ++ från Scratch.

Förprocessordirektiv i C ++

Vad du kommer att lära dig:

Översikt

Specialfunktionerna för förbehandling identifieras med hjälp av en enhet som kallas ”Preprocessor directive”. Dessa förprocessordirektiv berättar kompilatorn att viss information i C ++ - programmet som är markerat med förprocessordirektiven måste förbehandlas innan kompilering.

Observera att i C ++ börjar alla förprocessordirektiv med en '#' -symbol. I det ögonblick som förprocessorn (en del av kompilatorn) möter # -symbolen förbehandlas informationen efter symbolen # innan programmet skickas till kompilatorn.

Till skillnad från andra C ++ -uttalanden slutar förprocessordirektiven inte med semikolon.

I denna handledning kommer vi att utforska de olika förprocessordirektiven som stöds av C ++.

Direktiv om filintegrering

#omfatta

Direktivet om inkludering av filer #include tillåter oss att inkludera andra filer i vårt källprogram. Vi kan inkludera alla sidhuvudfiler som innehåller definitioner av olika fördefinierade funktioner i vårt program med hjälp av dessa funktioner. Vi kan inkludera rubrikfiler i vårt program med följande syntax.

#include

Exempel: #omfatta

Vi har redan sett detta i våra C ++ - program. Rubriken iostream innehåller de funktioner som krävs för in- / utdatastreaming som cout, cin, etc.

När våra program blir större eller funktionaliteten blir komplex kan vi dela upp vårt program i olika filer eller importera funktioner från de andra filerna. I det här fallet använder vi användardefinierade filer. För att inkludera användardefinierade filer i vårt program kan vi använda följande syntax av #include-direktivet.

#include “filename”

Exempel: # inkludera “vector_int.h”

Detta är en användardefinierad rubrikfil som vi tänker inkludera i vårt program för att kunna använda dess funktionalitet.

Nedanstående kodexempel visar användningen av #include-direktivet.

nätverksingenjör intervjuar frågor och svar i cisco
#include using namespace std; int main() { cout<<'This is an example demonstrating inclusion directive #include'; }

Produktion:

Detta är ett exempel som visar inkluderingsdirektivet #include.

Som visat har vi använt #include-direktivet för att inkludera rubrikens funktionalitet i vårt program.

Makrodefinitionsdirektiv

#definiera

#Define-direktivet används för att definiera de symboliska konstanterna eller makron i C ++ - programmet.

Den allmänna formen av ett #definera direktiv är:

#define macro_name replacement code

När en förprocessor möter makrot i programmet ersätter förprocessorn detta makro med koden som definieras med #define-direktivet innan koden skickas till kompilatorn.

Nedanstående kodexempel visar en symbolisk konstant RADIUS som definieras med #define-direktivet och dess användning i programmet.

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

Produktion:

Cirkelområde: 78,55

Som visas i programmet kan vi använda symbolisk konstant RADIUS i vår kod och den kommer att ersättas med det värde som definierats för det med #define-direktivet.

World of Warcraft gratis privat server

Vi kan använda #define-direktivet för att definiera en korrekt funktionskod. Dessa funktioner är vanligtvis små funktioner.

Ett exempel visas nedan.

#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; }

Produktion:

Arean av en rektangel är: 100

Här med hjälp av #define-direktivet har vi definierat en funktion REC_AREA som tar två argument, dvs. längd och bredd och beräknar ytan för en rektangel. I huvudfunktionen använder vi bara detta makro och levererar två argument till det för att erhålla arean av en rektangel.

#undef

Makron i ett program definierat med #define-direktivet håller tills det är odefinierat med #undef-direktivet. När programmet väl stöter på #undef kommer den efterföljande användningen av makro (odefinierad av #undef) att ge ett kompileringsfel.

I ovanstående program, om vi bara ger ett uttalande #undef REC_AREA efter heltalsdeklarationerna, kommer programmet att ge ett kompileringsfel.

Direktiv om villkorlig sammanställning

Bortsett från de riktlinjer som förklarats ovan, tillhandahåller C ++ även följande direktiv som kan användas för villkorlig sammanställning av kod. Dessa direktiv kan användas på liknande rader i if-else-uttalandet av C ++.

Till exempel, vi kan ställa in DEBUG för ett program PÅ eller AV med dessa villkorliga direktiv.

Några av de villkorliga sammanställningsdirektiven i C ++ inkluderar:

  • #om
  • #elif
  • #endif
  • #ifdef
  • #ifndef
  • #annan

Nedanstående program visar användningen av villkorliga kompileringsdirektiv i ett 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; }

Produktion:

Spårning: Start av huvudfunktionen
Maximalt är 100
Spårning: Slut på huvudfunktionen

I ovanstående program använder vi direktivet #ifdef - #endif för att definiera en DEBUG för programmet. Sedan definerade vi makrofunktionen MAX med #undef-direktivet. Direktivet om villkorlig sammanställning konstruerar #ifdef - #endif kontrollerar om DEBUG är inställt och om det är inställt skriver det ut några meddelanden i programmet.

Operatörerna # & ##

Operatorerna # och ## är två specialoperatorer som används för att konvertera en texttoken till en sträng som ska visas och sammanfoga två tokens.

Nedan ges ett exempel som visar båda dessa operatörer.

#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) = '<

Produktion:

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

I ovanstående program definierar vi MKSTR med ett argument x. Det har kropp #x. När vi skriver ut denna MKSTR med argumentet 'Hello World' ser vi att argumentet omvandlas till en sträng på grund av #x och visas för utdata.

webbplats som låter dig ladda ner youtube-videor

Därefter har vi definierat en konkatfunktion med två argument a och b. I kroppen anger vi ett ## b. Uttryck a ## b är lika med ab. Således i huvudfunktionen när vi kallar concat (x, y), utvärderas det faktiskt till xy vilket är lika med heltalsvariabeln som vi definierade.

Andra direktiv

#fel

Den allmänna syntaxen för #error-direktivet är:

#error error_message

När kompilatorn stöter på #error-direktivet, visas felmeddelandet och kompileringen stoppas. Argumentet error_message kan innehålla ett eller flera ord med eller utan citat.

#linje

Detta ber kompilatorn att ändra kompilatorns internt lagrade radnummer och filnamn till angivet radnummer och filnamn.

#linje siffersekvens (“filnamn”)

Siffersekvensen kan vara en heltalskonstant.

Exempel:#line 200 test.c

I exemplet ovan är det internt lagrade radnumret inställt på 200 och filnamnet ändras till test.c.

#pragma

Levererar implementeringsdefinierade instruktioner till kompilatorn. Dessa instruktioner är specifika för kompilatorn och plattformen. Om instruktionen inte matchar ignoreras direktivet utan att det skapas ett syntaxfel.

Fördefinierade makron

C ++ definierar också många fördefinierade makron som kan användas av programmerarna.

Några av dessa makron tabelleras nedan.

Fördefinierad makroBeskrivning
__FIL__Det aktuella filnamnet på programmet som kompileras
__DATUM__Datum för översättning av källkoden till objektkoden i formatet månad / dag / år
__TID__Tid i formulärets timme: minut: sekund då programmet sammanställs
__LINJE__Det aktuella radnumret för programmet som sammanställs
__cplusplusHeltalskonstant som definieras för varje kompilatorversion

Följande program visar dessa makron i ett 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<

Produktion:

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

Programutmatningen ovan är i linje med förklaringen av de fördefinierade makron ovan och är självförklarande.

Slutsats

I den här handledningen har vi sett olika förprocessordirektiv som tillhandahålls av C ++ tillsammans med deras exempel. Förprocessordirektiv hjälper oss att skriva mer effektiva program och mer läsbara program i viss utsträckning.

De villkorliga sammanställningsdirektiven tillåter oss också att förgrena vår programutgång på olika sätt.

=> Leta efter hela C ++ träningsserien här.

Rekommenderad läsning

^