Els preprocessadors són programes que processen el codi font abans de la compilació. Hi ha diversos passos entre escriure un programa i executar un programa en C. Fem una ullada a aquests passos abans de començar a aprendre sobre els preprocessadors.
Podeu veure els passos intermedis al diagrama anterior. El codi font escrit pels programadors s'emmagatzema primer en un fitxer, siga el nom programa.c . Aquest fitxer és processat pels preprocessadors i es genera un fitxer de codi font ampliat anomenat program.i. Aquest fitxer ampliat el compila el compilador i es genera un fitxer de codi objecte anomenat program.obj. Finalment, l'enllaçador enllaça aquest fitxer de codi objecte amb el codi objecte de les funcions de la biblioteca per generar el fitxer executable program.exe.
Directives de preprocessador a C
Els programes de preprocessador proporcionen directives de preprocessador que diuen al compilador que preprocessï el codi font abans de compilar. Totes aquestes directives de preprocessador comencen amb un símbol '#' (hash). El símbol '#' indica que qualsevol instrucció que comenci amb un '#' anirà al programa del preprocessador perquè s'executi. Podem col·locar aquestes directives de preprocessador a qualsevol lloc del nostre programa.
Alguns exemples d'algunes directives de preprocessador són: #incloure , #definir , #ifndef, etc.
Nota Recordeu que el # El símbol només proporciona una ruta al preprocessador i el programa preprocessador processa una ordre com ara include. Per exemple, #include inclourà el codi o el contingut del fitxer especificat al vostre programa.
Llista de directives de preprocessador a C
La taula següent enumera totes les directives del preprocessador en C:
| Directives de preprocessador | Descripció |
|---|---|
| #definir | S'utilitza per definir una macro |
| #undef | S'utilitza per no definir una macro |
| #incloure | S'utilitza per incloure un fitxer al programa de codi font |
| #ifdef | S'utilitza per incloure una secció de codi si una determinada macro està definida per #define |
| #ifndef | S'utilitza per incloure una secció de codi si una macro determinada no està definida per #define |
| #si | Comproveu la condició especificada |
| #una altra cosa | Codi alternatiu que s'executa quan falla #if |
| #endif | S'utilitza per marcar el final de #if, #ifdef i #ifndef |
Aquests preprocessadors es poden classificar en funció del tipus de funció que realitzen.
Tipus de preprocessadors C
Hi ha 4 tipus principals de directives de preprocessador:
- Macros
- Inclusió de fitxers
- Recopilació condicional
- Altres directives
Anem a conèixer amb detall cadascuna d'aquestes directrius.
1. Macros
En C, les macros són fragments de codi d'un programa que rep algun nom. Sempre que el compilador troba aquest nom, el compilador substitueix el nom pel fragment de codi real. El '#definir' La directiva s'utilitza per definir una macro.
Sintaxi de la definició de macro
#define token value>
on després del preprocessament, el testimoni s'ampliarà a la seva valor al programa.
Exemple 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; }> |
>
>Sortida
0 1 2 3 4>
En el programa anterior, quan el compilador executa la paraula LÍMIT, la substitueix per 5. La paraula 'LIMIT' en la definició macro s'anomena plantilla de macro i '5' és una macro expansió.
base de dades java jdbc
Nota No hi ha punt i coma (;) al final de la definició de macro. Les definicions de macro no necessiten un punt i coma per acabar.
També n'hi ha Macros predefinides en C que són útils per proporcionar diverses funcionalitats al nostre programa.
Macros amb arguments
També podem passar arguments a macros. Les macros definides amb arguments funcionen de manera similar a les funcions.
Exemple
#define foo( a, b ) a + b #define func(r) r * r>
Entenem-ho amb un programa:
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;> }> |
llista j
>
>Sortida
Area of rectangle is: 50>
Podem veure amb el programa anterior que sempre que el compilador troba AREA(l, b) al programa, la substitueix per la instrucció (l*b). No només això, sinó que els valors passats a la plantilla de macro AREA(l, b) també es substituiran a la instrucció (l*b). Per tant AREA(10, 5) serà igual a 10*5.
2. Inclusió d'arxius
Aquest tipus de directiva de preprocessador indica al compilador que inclogui un fitxer al programa de codi font. El Directiva de preprocessador #include s'utilitza per incloure els fitxers de capçalera al programa C.
Hi ha dos tipus de fitxers que l'usuari pot incloure al programa:
Fitxers de capçalera estàndard
Els fitxers de capçalera estàndard contenen definicions de funcions predefinides com printf(), scanf(), etc. Aquests fitxers s'han d'incloure per treballar amb aquestes funcions. Es declaren diferents funcions en diferents fitxers de capçalera.
Per exemple, les funcions d'E/S estàndard es troben al fitxer 'iostream', mentre que les funcions que realitzen operacions de cadena es troben al fitxer 'cadena'.
Sintaxi
#include < file_name>>
on nom de l'arxiu és el nom del fitxer de capçalera que s'ha d'incloure. El '' claudàtors digueu al compilador que cerqui el fitxer al s directori estàndard.
Fitxers de capçalera definits per l'usuari
Quan un programa es fa molt gran, és una bona pràctica dividir-lo en fitxers més petits i incloure-los sempre que sigui necessari. Aquest tipus de fitxers són fitxers de capçalera definits per l'usuari.
Sintaxi
#include ' filename '>
El cometes dobles ( ) digueu al compilador que cerqui el fitxer de capçalera al fitxer directori del fitxer font.
3. Recopilació condicional
Compilació condicional en directives C és un tipus de directiva que ajuda a compilar una part específica del programa o a saltar la compilació d'alguna part específica del programa en funció d'algunes condicions. Hi ha les següents directives de preprocessador que s'utilitzen per inserir codi condicional:
- Directiva #if
- Directiva #ifdef
- Directiva #ifndef
- Directiva #else
- Directiva #elif
- Directiva #endif
#endif La directiva s'utilitza per tancar les directives d'obertura #if, #ifdef i #ifndef, la qual cosa significa que el preprocessament d'aquestes directives s'ha completat.
Sintaxi
#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>
Si la macro amb el nom ' macro_nom ' està definit, aleshores el bloc d'instruccions s'executarà amb normalitat, però si no està definit, el compilador simplement ometrà aquest bloc d'instruccions.
Exemple
L'exemple següent demostra l'ús de les directives del preprocessador #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;> }> |
>
>Sortida
PI is defined Square is not defined>
4. Altres directives
A part de les directives anteriors, hi ha dues directives més que no s'utilitzen habitualment. Aquests són:
- Directiva #undef
- Directiva #pragma
1. Directiva #undef
La directiva #undef s'utilitza per no definir una macro existent. Aquesta directiva funciona com:
#undef LIMIT>
L'ús d'aquesta declaració no definirà la macro existent LIMIT. Després d'aquesta declaració, cada instrucció #ifdef LIMIT es valorarà com a falsa.
Exemple
L'exemple següent mostra el funcionament de la directiva #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;> }> |
>
>
operadors javascriptSortida
Min value is: 10 Min value after undef and again redefining it: 20>
2. Directiva #pragma
Aquesta directiva és una directiva de propòsit especial i s'utilitza per activar o desactivar algunes funcions. Aquests tipus de directives són específiques del compilador, és a dir, varien d'un compilador a un altre.
Sintaxi
#pragma directive>
A continuació es comenten algunes de les directrius de #pragma:
- Inici de #pragma: Aquestes directives ens ajuden a especificar les funcions que cal executar abans de l'inici del programa (abans que el control passi a main()).
- Sortida del #pragma : Aquestes directives ens ajuden a especificar les funcions que es necessiten per executar-se just abans de la sortida del programa (just abans que el control torni de main()).
El programa següent no funcionarà amb els compiladors GCC.
Exemple
El programa a continuació il·lustrar l'ús de la sortida de #pragma i l'inici de pragma
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;> }> |
>
>
Sortida esperada
Inside func1() Inside main() Inside func2()>
El codi anterior produirà la sortida tal com es mostra a continuació quan s'executa als compiladors GCC:
Inside main()c>
Això passa perquè GCC no admet l'inici ni la sortida de #pragma. Tanmateix, podeu utilitzar el codi següent per a la sortida esperada als compiladors 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;> }> |
>
>Sortida
Inside func1() Inside main() Inside func2()>
En el programa anterior, n'hem utilitzat alguns sintaxis específiques de manera que una de les funcions s'executa abans de la funció principal i l'altra s'executa després de la funció principal.
Directiva d'advertència #pragma
Aquesta directiva s'utilitza per ocultar el missatge d'advertència que es mostra durant la compilació. Podem amagar els avisos com es mostra a continuació:
- #pragma advertir -rvl : Aquesta directiva amaga aquells avisos que es generen quan una funció que se suposa que retorna un valor no retorna cap valor.
- #pragma advertir -par : Aquesta directiva amaga aquells avisos que es generen quan una funció no utilitza els paràmetres que se li han passat.
- #pragma advertir -rch : Aquesta directiva amaga aquells avisos que es generen quan un codi no és accessible. Per exemple, qualsevol codi escrit després de tornar La declaració d'una funció és inaccessible.
Si t'agrada techcodeview.com i vols contribuir, també pots escriure un article utilitzant . Vegeu el vostre article que apareix a la pàgina principal de techcodeview.com i ajudeu altres Geeks. Si us plau, escriviu comentaris si trobeu alguna cosa incorrecta o si voleu compartir més informació sobre el tema tractat anteriorment.