Meniu

Directivele preprocesorului în C ++

preprocessor directives c

Încercați Instrumentul Nostru Pentru Eliminarea Problemelor

O privire detaliată asupra directivelor preprocesorului în C ++.

Preprocesorul este o caracteristică unică a C ++. În C ++, avem pași precum compilarea, legarea și execuția pentru un program tipic. În realitate, avem o mulțime de alte caracteristici într-un program C ++ care trebuie procesat înainte de a trece programul pentru compilare.

În acest scop, se efectuează un pas special numit preprocesare. Preprocesarea se efectuează înainte de procesul de compilare și caracteristicile speciale sunt preprocesate. Ca rezultat, se obține un program C ++ extins și apoi este trecut la compilator.

=> Vizitați aici pentru a afla C ++ de la zero.

Directivele preprocesorului în C ++

Ce veți învăța:

Prezentare generală

Caracteristicile speciale pentru preprocesare sunt identificate folosind o entitate numită „directivă preprocesor”. Aceste directive de preprocesare spun compilatorului că anumite informații din programul C ++ marcate cu directive de preprocesare trebuie să fie preprocesate înainte de compilare.

Rețineți că în C ++ toate directivele preprocesorului încep cu simbolul „#”. În momentul în care preprocesorul (o parte a compilatorului) întâlnește simbolul #, informațiile care urmează simbolului # sunt preprocesate înainte de a trece programul la compilator.

Spre deosebire de celelalte instrucțiuni C ++, directivele preprocesorului nu se termină cu punct și virgulă.

În acest tutorial, vom explora diferitele directive preprocesor acceptate de C ++.

Directivele privind includerea fișierelor

#include

Directiva de includere a fișierelor #include ne permite să includem alte fișiere în programul nostru sursă. Putem include orice fișier antet care conține definiții ale diferitelor funcții predefinite în programul nostru folosind aceste funcții. Putem include fișiere antet în programul nostru folosind următoarea sintaxă.

#include

Exemplu: #include

Am văzut deja acest lucru în programele noastre C ++. Antetul iostream conține funcțiile necesare pentru fluxul de date de intrare / ieșire, cum ar fi cout, cin etc.

Pe măsură ce programele noastre se măresc sau funcționalitatea devine complexă, ne-ar putea dori să împărțim programul în diferite fișiere sau să importăm funcționalități din celelalte fișiere. În acest caz, folosim fișiere definite de utilizator. Pentru a include fișiere definite de utilizator în programul nostru putem folosi următoarea sintaxă a directivei #include.

#include “filename”

Exemplu: #include „vector_int.h”

Acesta este un fișier antet definit de utilizator pe care intenționăm să îl includem în programul nostru pentru a-i folosi funcționalitatea.

Exemplul de cod de mai jos arată utilizarea directivei #include.

există o versiune gratuită de quickbooks
#include using namespace std; int main() { cout<<'This is an example demonstrating inclusion directive #include'; }

Ieșire:

Acesta este un exemplu care demonstrează directiva de includere #include.

După cum se arată, am folosit directiva #include pentru a include funcționalitatea antetului în programul nostru.

Directivele de definire macro

#defini

Directiva #define este utilizată pentru a defini constantele simbolice sau macrocomenzile din programul C ++.

Forma generală a unei directive #define este:

#define macro_name replacement code

Când un preprocesator întâlnește macrocomanda din program, preprocesorul înlocuiește această macrocomandă cu codul care este definit folosind directiva #define înainte ca codul să fie transmis la compilator.

Exemplul de cod de mai jos arată o constantă simbolică RADIUS care este definită folosind directiva #define și utilizarea acesteia în program.

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

Ieșire:

Suprafața unui cerc: 78,55

Așa cum se arată în program, putem folosi constanta simbolică RADIUS în codul nostru și va fi înlocuită cu valoarea definită pentru aceasta folosind directiva #define.

care este mai bine java sau c ++

Putem folosi directiva #define pentru a defini un cod funcțional adecvat. Aceste funcții sunt de obicei funcții mici.

Un exemplu este prezentat mai jos.

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

Ieșire:

Aria unui dreptunghi este: 100

Aici folosind directiva #define am definit o funcție REC_AREA care ia două argumente adică lungimea și lățimea și calculează aria unui dreptunghi. În funcția principală, doar folosim această macro și îi furnizăm două argumente pentru a obține aria unui dreptunghi.

#undef

Macrocomenzile dintr-un program definit cu directiva #define durează până când este nedefinită folosind directiva #undef. Odată ce programul întâlnește #undef, utilizarea ulterioară a macro-ului (nedefinit de #undef) va da o eroare de compilare.

În programul de mai sus, dacă dăm doar o declarație #undef REC_AREA după declarațiile întregi, atunci programul va da o eroare de compilare.

Directivele de compilare condiționată

În afară de directivele explicate mai sus, C ++ oferă și următoarele directive care pot fi utilizate pentru compilarea condiționată a codului. Aceste directive pot fi utilizate pe linii similare ale instrucțiunii if-else a C ++.

De exemplu, putem seta DEBUG pentru un program ON sau OFF folosind aceste directive condiționale.

Unele dintre directivele de compilare condiționate prevăzute în C ++ includ:

  • #dacă
  • #elif
  • #endif
  • #ifdef
  • #ifndef
  • #else

Programul de mai jos demonstrează utilizarea directivelor de compilare condiționată într-un program C ++.

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

Ieșire:

Urmărire: începutul funcției principale
Maximul este de 100
Urmărire: sfârșitul funcției principale

În programul de mai sus, folosim directiva #ifdef - #endif pentru a defini un DEBUG pentru program. Apoi am nedefinit funcția macro MAX folosind directiva #undef. Directiva de compilare condițională construiește #ifdef - #endif verifică dacă DEBUG este setat și dacă este setat, tipărește câteva mesaje în program.

Operatorii # & ##

Operatorii # și ## sunt doi operatori speciali care sunt utilizați respectiv pentru a converti un jeton de text într-un șir care trebuie afișat și concatenat două jetoane.

Mai jos este prezentat un exemplu care demonstrează ambii acești operatori.

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

Ieșire:

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

În programul de mai sus, definim MKSTR cu un argument x. Are corpul #x. Când tipărim acest MKSTR folosind argumentul „Hello World”, vedem că din cauza #x, argumentul este convertit într-un șir și este afișat la ieșire.

În continuare, am definit o funcție concat cu două argumente a și b. În corp specificăm un ## b. Expresia a ## b este egală cu ab. Astfel, în funcția principală atunci când numim concat (x, y), se evaluează de fapt la xy care este egală cu variabila întreagă pe care am definit-o.

Alte directive

#eroare

Sintaxa generală a directivei #error este:

Întrebări și răspunsuri pentru interviul dezvoltatorului sq sql
#error error_message

Când compilatorul întâlnește directiva #error, acesta afișează mesajul error_message și compilarea se oprește. Argumentul error_message poate conține unul sau mai multe cuvinte cu sau fără ghilimele.

#linia

Aceasta îi spune compilatorului să schimbe numărul de linie și numele de fișier stocate intern al compilatorului la numărul de linie și numele de fișier date.

#linia secvență de cifre („nume de fișier”)

Secvența_cifră poate fi o constantă întreagă.

Exemplu:#line 200 test.c

În exemplul de mai sus, numărul liniei stocate intern este setat la 200 și numele fișierului este schimbat în test.c.

#pragma

Furnizează instrucțiunilor definite de implementare către compilator. Aceste instrucțiuni sunt specifice compilatorului și platformei. Dacă instrucțiunea nu se potrivește, directiva este ignorată fără a genera o eroare de sintaxă.

Macrocomenzi predefinite

C ++ definește, de asemenea, numeroase macro-uri predefinite care pot fi utilizate de programatori.

Unele dintre aceste macrocomenzi sunt tabelate mai jos.

Macro predefinitDescriere
__FIŞIER__Numele fișierului curent al programului care este compilat
__DATA__Data traducerii codului sursă în cod obiect în formatul lună / zi / an
__TIMP__Ora în forma oră: minut: a doua la care programul este compilat
__LINIA__Numărul de linie curent al programului care este compilat
__plusplusConstantă de număr întreg care este definită pentru fiecare versiune a compilatorului

Următorul program demonstrează aceste macrocomenzi într-un 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<

Ieșire:

__LINE__: 5
__FILE__: prog.cpp
__DATE__ :Apr 15 2019
__TIME__: 12: 09: 15
__plusplus: 201402

Ieșirea programului de mai sus este în concordanță cu explicația macro-urilor predefinite de mai sus și este auto-explicativă.

Concluzie

În acest tutorial, am văzut diverse directive preprocesor furnizate de C ++ împreună cu exemplele lor. Directivele preprocesorului ne ajută să scriem programe mai eficiente și programe mai lizibile într-o oarecare măsură.

Directivele de compilare condiționată ne permit, de asemenea, să ne ramificăm rezultatele programului în diferite moduri.

=> Căutați întreaga serie de formare C ++ aici.

Lectură recomandată

^