Preprocesoarele sunt programe care procesează codul sursă înainte de compilare. Sunt implicați mai mulți pași între scrierea unui program și executarea unui program în C. Să aruncăm o privire la acești pași înainte de a începe efectiv să învățăm despre Preprocesoare.
Puteți vedea pașii intermediari în diagrama de mai sus. Codul sursă scris de programatori este mai întâi stocat într-un fișier, fie numele program.c . Acest fișier este apoi procesat de preprocesoare și este generat un fișier de cod sursă extins numit program.i. Acest fișier extins este compilat de compilator și este generat un fișier de cod obiect numit program.obj. În cele din urmă, linkerul leagă acest fișier cod obiect la codul obiect al funcțiilor bibliotecii pentru a genera fișierul executabil program.exe.
Directivele privind preprocesorul din C
Programele de preprocesor oferă directive de preprocesor care îi spun compilatorului să preproceseze codul sursă înainte de compilare. Toate aceste directive de preprocesor încep cu un simbol „#” (hash). Simbolul „#” indică faptul că orice instrucțiune care începe cu „#” va merge la programul preprocesor pentru a fi executată. Putem plasa aceste directive de preprocesor oriunde în programul nostru.
webdriver
Exemple de directive de preprocesor sunt: #include , #defini , #ifndef, etc.
Notă Amintiți-vă că # simbolul oferă doar o cale către preprocesor, iar o comandă precum include este procesată de programul preprocesor. De exemplu, #include va include codul sau conținutul fișierului specificat în programul dvs.
Lista directivelor de preprocesor în C
Următorul tabel listează toate directivele de preprocesor din C:
| Directive privind preprocesorul | Descriere |
|---|---|
| #defini | Folosit pentru a defini o macrocomandă |
| #undef | Folosit pentru a nedefini o macrocomandă |
| #include | Folosit pentru a include un fișier în programul de cod sursă |
| #ifdef | Folosit pentru a include o secțiune de cod dacă o anumită macrocomandă este definită de #define |
| #ifndef | Folosit pentru a include o secțiune de cod dacă o anumită macrocomandă nu este definită de #define |
| #dacă | Verificați starea specificată |
| #altfel | Cod alternativ care se execută atunci când #if eșuează |
| #endif | Folosit pentru a marca sfârșitul lui #if, #ifdef și #ifndef |
Aceste preprocesoare pot fi clasificate în funcție de tipul de funcție pe care o îndeplinesc.
Tipuri de preprocesoare C
Există 4 tipuri principale de directive de preprocesor:
- Macro-uri
- Includerea fișierului
- Compilare condiționată
- Alte directive
Să aflăm acum despre fiecare dintre aceste directive în detaliu.
1. Macro-uri
În C, macrourile sunt bucăți de cod dintr-un program căruia i se dă un nume. Ori de câte ori acest nume este întâlnit de compilator, compilatorul înlocuiește numele cu fragmentul real de cod. The '#defini' directiva este folosită pentru a defini o macrocomandă.
Sintaxa definiției macro
#define token value>
unde după preprocesare, jeton va fi extins la acesta valoare în program.
Exemplu de macro
C
// C Program to illustrate the macro> #include> // macro definition> #define LIMIT 5> int> main()> {> >for> (>int> i = 0; i printf('%d
', i); } return 0; }> |
>
>Ieșire
0 1 2 3 4>
În programul de mai sus, când compilatorul execută cuvântul LIMIT, îl înlocuiește cu 5. Cuvântul 'LIMITĂ' în definiția macro se numește șablon macro și „5” este extinderea macro.
Notă Nu există punct și virgulă (;) la sfârșitul definiției macro. Definițiile macro nu au nevoie de punct și virgulă pentru a se termina.
Există și unii Macrocomenzi predefinite în C care sunt utile în furnizarea diverselor funcționalități programului nostru.
Macro-uri cu argumente
De asemenea, putem transmite argumente macrocomenzi. Macro-urile definite cu argumente funcționează similar cu funcțiile.
Exemplu
#define foo( a, b ) a + b #define func(r) r * r>
Să înțelegem asta cu un program:
C
// C Program to illustrate function like macros> #include> // macro with parameter> #define AREA(l, b) (l * b)> int> main()> {> >int> l1 = 10, l2 = 5, area;> >area = AREA(l1, l2);> >printf>(>'Area of rectangle is: %d'>, area);> >return> 0;> }> |
>
>Ieșire
Area of rectangle is: 50>
Putem vedea din programul de mai sus că ori de câte ori compilatorul găsește AREA(l, b) în program, o înlocuiește cu instrucțiunea (l*b). Nu numai asta, dar și valorile transmise șablonului macro AREA(l, b) vor fi înlocuite în instrucțiunea (l*b). Prin urmare, AREA(10, 5) va fi egală cu 10*5.
2. Includerea fișierului
Acest tip de directivă de preprocesor îi spune compilatorului să includă un fișier în programul de cod sursă. The #include directiva de preprocesor este folosit pentru a include fișierele antet în programul C.
Există două tipuri de fișiere care pot fi incluse de către utilizator în program:
Fișiere antet standard
Fișierele de antet standard conțin definiții ale funcțiilor predefinite, cum ar fi printf(), scanf(), etc. Aceste fișiere trebuie incluse pentru a funcționa cu aceste funcții. Funcții diferite sunt declarate în fișiere de antet diferite.
De exemplu, funcțiile standard I/O sunt în fișierul „iostream”, în timp ce funcțiile care efectuează operațiuni cu șir sunt în fișierul „șir”.
Sintaxă
#include < file_name>>>>Unde nume de fișier este numele fișierului antet care trebuie inclus. The '' paranteze spuneți compilatorului să caute fișierul în s directorul standard.
Fișiere antet definite de utilizator
Când un program devine foarte mare, este o practică bună să-l împărțiți în fișiere mai mici și să le includeți ori de câte ori este necesar. Aceste tipuri de fișiere sunt fișiere antet definite de utilizator.
Sintaxă
The ghilimele duble ( ) spuneți compilatorului să caute fișierul antet în fișierul directorul fișierului sursă.
3. Compilare condiționată
Compilarea condiționată în directivele C este un tip de directivă care ajută la compilarea unei anumite porțiuni a programului sau la omiterea compilarii unei anumite părți a programului pe baza unor condiții. Există următoarele directive de preprocesor care sunt utilizate pentru a introduce codul condiționat:
convertiți int în șir de caractere java
- #if Directiva
- Directiva #ifdef
- Directiva #ifndef
- Directiva #else
- Directiva #elif
- Directiva #endif
#endif directiva este folosită pentru a închide directivele de deschidere #if, #ifdef și #ifndef, ceea ce înseamnă că preprocesarea acestor directive este finalizată.
Sintaxă
#ifdef macro_name // Code to be executed if macro_name is defined # ifndef macro_name // Code to be executed if macro_name is not defined #if constant_expr // Code to be executed if constant_expression is true #elif another_constant_expr // Code to be excuted if another_constant_expression is true #else // Code to be excuted if none of the above conditions are true #endif>
Dacă macro-ul cu numele „ macro_name ‘ este definit, atunci blocul de instrucțiuni se va executa normal, dar dacă nu este definit, compilatorul va omite pur și simplu acest bloc de instrucțiuni.
Exemplu
Exemplul de mai jos demonstrează utilizarea directivelor de preprocesor #include #if, #elif, #else și #endif.
C
//program to demonstrates the use of #if, #elif, #else,> // and #endif preprocessor directives.> #include> // defining PI> #define PI 3.14159> int> main()> {> > #ifdef PI> >printf>(>'PI is defined
'>);> > #elif defined(SQUARE)> >printf>(>'Square is defined
'>);> #else> >#error 'Neither PI nor SQUARE is defined'> #endif> > #ifndef SQUARE> >printf>(>'Square is not defined'>);> #else> >cout <<>'Square is defined'> << endl;> #endif> >return> 0;> }> |
sincronizare java
>
>Ieșire
PI is defined Square is not defined>
4. Alte directive
În afară de directivele de mai sus, mai există două directive care nu sunt utilizate în mod obișnuit. Acestea sunt:
- Directiva #undef
- Directiva #pragma
1. Directiva #undef
Directiva #undef este folosită pentru a nedefini o macrocomandă existentă. Această directivă funcționează ca:
#undef LIMIT>
Folosirea acestei instrucțiuni va nedefini macro-ul LIMIT existent. După această declarație, fiecare instrucțiune #ifdef LIMIT va fi evaluată ca fiind falsă.
Exemplu
Exemplul de mai jos demonstrează funcționarea Directivei #undef.
C
#include> // defining MIN_VALUE> #define MIN_VALUE 10> int> main() {> >// Undefining and redefining MIN_VALUE> printf>(>'Min value is: %d
'>,MIN_VALUE);> > //undefining max value> #undef MIN_VALUE> > // again redefining MIN_VALUE> #define MIN_VALUE 20> >printf>(>'Min value after undef and again redefining it: %d
'>, MIN_VALUE);> >return> 0;> }> |
>
>Ieșire
Min value is: 10 Min value after undef and again redefining it: 20>
2. Directiva #pragma
Această directivă este o directivă cu scop special și este folosită pentru a activa sau dezactiva unele funcții. Aceste tipuri de directive sunt specifice compilatorului, adică variază de la compilator la compilator.
Sintaxă
#pragma directive>
Unele dintre directivele #pragma sunt discutate mai jos:
- #pragma startup: Aceste directive ne ajută să specificăm funcțiile care sunt necesare pentru a rula înainte de pornirea programului (înainte ca controlul să treacă la main()).
- #pragma ieșire : Aceste directive ne ajută să specificăm funcțiile care sunt necesare pentru a rula chiar înainte de ieșirea programului (chiar înainte ca controlul să revină din main()).
Programul de mai jos nu va funcționa cu compilatoarele GCC.
Exemplu
Programul de mai jos ilustrează folosirea #pragma exit și pragma startup
C
// C program to illustrate the #pragma exit and pragma> // startup> #include> void> func1();> void> func2();> // specifying funct1 to execute at start> #pragma startup func1> // specifying funct2 to execute before end> #pragma exit func2> void> func1() {>printf>(>'Inside func1()
'>); }> void> func2() {>printf>(>'Inside func2()
'>); }> // driver code> int> main()> {> >void> func1();> >void> func2();> >printf>(>'Inside main()
'>);> >return> 0;> }> |
>
>
Rezultat așteptat
Inside func1() Inside main() Inside func2()>
Codul de mai sus va produce rezultatul prezentat mai jos atunci când este rulat pe compilatoarele GCC:
Inside main()c>
Acest lucru se întâmplă deoarece GCC nu acceptă pornirea sau ieșirea #pragma. Cu toate acestea, puteți utiliza codul de mai jos pentru rezultatul așteptat pe compilatoarele GCC.
C
#include> void> func1();> void> func2();> void> __attribute__((constructor)) func1();> void> __attribute__((destructor)) func2();> void> func1()> {> >printf>(>'Inside func1()
'>);> }> void> func2()> {> >printf>(>'Inside func2()
'>);> }> int> main()> {> >printf>(>'Inside main()
'>);> >return> 0;> }> |
bolding în css
>
>Ieșire
Inside func1() Inside main() Inside func2()>
În programul de mai sus, am folosit câteva sintaxe specifice astfel încât una dintre funcții se execută înaintea funcției principale și cealaltă se execută după funcția principală.
Directiva #pragma warn
Această directivă este folosită pentru a ascunde mesajul de avertizare care este afișat în timpul compilării. Putem ascunde avertismentele așa cum se arată mai jos:
- #pragma warn -rvl : Această directivă ascunde acele avertismente care apar atunci când o funcție care ar trebui să returneze o valoare nu returnează o valoare.
- #pragma warn -par : Această directivă ascunde acele avertismente care apar atunci când o funcție nu folosește parametrii trecuți.
- #pragma warn -rch : Această directivă ascunde acele avertismente care apar atunci când un cod este inaccesibil. De exemplu, orice cod scris după întoarcere declarația dintr-o funcție este inaccesibilă.
Dacă vă place techcodeview.com și doriți să contribui, puteți scrie și un articol folosind . Vedeți articolul dvs. care apare pe pagina principală techcodeview.com și ajutați alți Geeks. Vă rugăm să scrieți comentarii dacă găsiți ceva incorect sau dacă doriți să împărtășiți mai multe informații despre subiectul discutat mai sus.