Los preprocesadores son programas que procesan el código fuente antes de la compilación. Hay varios pasos involucrados entre escribir un programa y ejecutarlo en C. Echemos un vistazo a estos pasos antes de comenzar a aprender sobre los preprocesadores.
Puede ver los pasos intermedios en el diagrama anterior. El código fuente escrito por los programadores se almacena primero en un archivo, sea el nombre programa.c . Luego, los preprocesadores procesan este archivo y se genera un archivo de código fuente expandido llamado program.i. Este archivo expandido es compilado por el compilador y se genera un archivo de código objeto llamado program.obj. Finalmente, el vinculador vincula este archivo de código objeto al código objeto de las funciones de la biblioteca para generar el archivo ejecutable program.exe.
Directivas de preprocesador en C
Los programas de preprocesador proporcionan directivas de preprocesador que le indican al compilador que preprocese el código fuente antes de compilarlo. Todas estas directivas de preprocesador comienzan con un símbolo '#' (almohadilla). El símbolo '#' indica que cualquier declaración que comience con '#' irá al programa preprocesador para ser ejecutada. Podemos colocar estas directivas de preprocesador en cualquier parte de nuestro programa.
Ejemplos de algunas directivas de preprocesador son: #incluir , #definir , #ifndef, etc.
Nota Recuerde que el # El símbolo solo proporciona una ruta al preprocesador, y el programa del preprocesador procesa un comando como incluir. Por ejemplo, #include incluirá el código o el contenido del archivo especificado en su programa.
Lista de directivas de preprocesador en C
La siguiente tabla enumera todas las directivas del preprocesador en C:
| Directivas del pre procesador | Descripción |
|---|---|
| #definir | Se utiliza para definir una macro. |
| #undef | Se utiliza para anular la definición de una macro. |
| #incluir | Se utiliza para incluir un archivo en el programa de código fuente. |
| #ifdef | Se utiliza para incluir una sección de código si una determinada macro está definida por #define |
| #ifndef | Se utiliza para incluir una sección de código si una determinada macro no está definida por #define |
| #si | Verifique la condición especificada |
| #demás | Código alternativo que se ejecuta cuando #if falla |
| #terminara si | Se utiliza para marcar el final de #if, #ifdef y #ifndef. |
Estos preprocesadores se pueden clasificar según el tipo de función que realizan.
Tipos de preprocesadores C
Hay 4 tipos principales de directivas de preprocesador:
- macros
- Inclusión de archivos
- Compilación condicional
- Otras directivas
Conozcamos ahora en detalle cada una de estas directivas.
1. macros
En C, las macros son fragmentos de código de un programa al que se le da algún nombre. Siempre que el compilador encuentra este nombre, reemplaza el nombre con el fragmento de código real. El '#definir' La directiva se utiliza para definir una macro.
Sintaxis de la definición de macro
#define token value>
donde después del preprocesamiento, el simbólico se ampliará a su valor en el programa.
Ejemplo 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; }> |
java reemplaza toda la cadena
>
>Producción
0 1 2 3 4>
En el programa anterior, cuando el compilador ejecuta la palabra LIMIT, la reemplaza con 5. La palabra 'LÍMITE' en la definición de macro se llama plantilla macro y '5' es macroexpansión.
Nota No hay punto y coma (;) al final de la definición de macro. Las definiciones de macros no necesitan un punto y coma para finalizar.
También hay algunos Macros predefinidas en C los cuales son útiles para proporcionar diversas funcionalidades a nuestro programa.
Macros con argumentos
También podemos pasar argumentos a macros. Las macros definidas con argumentos funcionan de manera similar a las funciones.
Ejemplo
#define foo( a, b ) a + b #define func(r) r * r>
Entendamos esto con 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;> }> |
>
>Producción
Area of rectangle is: 50>
Podemos ver en el programa anterior que cada vez que el compilador encuentra AREA(l, b) en el programa, la reemplaza con la declaración (l*b). No solo esto, sino que los valores pasados a la plantilla de macro AREA(l, b) también serán reemplazados en la declaración (l*b). Por lo tanto AREA(10, 5) será igual a 10*5.
2. Inclusión de archivos
Este tipo de directiva de preprocesador le dice al compilador que incluya un archivo en el programa de código fuente. El #incluir directiva de preprocesador se utiliza para incluir los archivos de encabezado en el programa C.
Hay dos tipos de archivos que el usuario puede incluir en el programa:
Archivos de encabezado estándar
Los archivos de encabezado estándar contienen definiciones de funciones predefinidas como imprimirf(), escanear(), etc. Estos archivos deben incluirse para trabajar con estas funciones. Se declaran diferentes funciones en diferentes archivos de encabezado.
Por ejemplo, las funciones de E/S estándar están en el archivo 'iostream', mientras que las funciones que realizan operaciones de cadena están en el archivo 'string'.
Sintaxis
#include < file_name>>
dónde Nombre del archivo es el nombre del archivo de encabezado que se incluirá. El '' soportes decirle al compilador que busque el archivo en el s directorio estándar.
Archivos de encabezado definidos por el usuario
Cuando un programa se vuelve muy grande, es una buena práctica dividirlo en archivos más pequeños e incluirlos cuando sea necesario. Estos tipos de archivos son archivos de encabezado definidos por el usuario.
Sintaxis
#include ' filename '>
El doble comillas ( ) decirle al compilador que busque el archivo de encabezado en el directorio del archivo fuente.
3. Compilación condicional
Compilación condicional en directivas C es un tipo de directiva que ayuda a compilar una parte específica del programa o a omitir la compilación de alguna parte específica del programa en función de algunas condiciones. Existen las siguientes directivas de preprocesador que se utilizan para insertar código condicional:
- #si Directiva
- Directiva #ifdef
- Directiva #ifndef
- #más directiva
- Directiva #elif
- Directiva #endif
#terminara si La directiva se utiliza para cerrar las directivas de apertura #if, #ifdef y #ifndef, lo que significa que se completa el preprocesamiento de estas directivas.
Sintaxis
#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 con el nombre ' nombre_macro 'está definido, entonces el bloque de declaraciones se ejecutará normalmente, pero si no está definido, el compilador simplemente omitirá este bloque de declaraciones.
Ejemplo
El siguiente ejemplo demuestra el uso de las directivas de preprocesador #include #if, #elif, #else y #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;> }> |
>
>
convertir un número entero a una cadena javaProducción
PI is defined Square is not defined>
4. Otras directivas
Aparte de las directivas anteriores, hay dos directivas más que no se utilizan habitualmente. Estos son:
- Directiva #undef
- Directiva #pragma
1. Directiva #undef
La directiva #undef se utiliza para anular la definición de una macro existente. Esta directiva funciona como:
#undef LIMIT>
El uso de esta declaración anulará la definición del LÍMITE de macro existente. Después de esta declaración, cada declaración #ifdef LIMIT se evaluará como falsa.
Ejemplo
El siguiente ejemplo demuestra el funcionamiento 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;> }> |
>
>Producción
Min value is: 10 Min value after undef and again redefining it: 20>
2. Directiva #pragma
Esta directiva es una directiva de propósito especial y se utiliza para activar o desactivar algunas funciones. Estos tipos de directivas son específicas del compilador, es decir, varían de un compilador a otro.
Sintaxis
#pragma directive>
Algunas de las directivas #pragma se analizan a continuación:
- #inicio pragma: Estas directivas nos ayudan a especificar las funciones que se necesitan ejecutar antes del inicio del programa (antes de que el control pase a main()).
- #pragma salida : Estas directivas nos ayudan a especificar las funciones que se necesitan ejecutar justo antes de que salga el programa (justo antes de que el control regrese de main()).
El siguiente programa no funcionará con los compiladores GCC.
Ejemplo
El siguiente programa ilustrar el uso de #pragma exit y 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;> }> |
>
>
Rendimiento esperado
Inside func1() Inside main() Inside func2()>
El código anterior producirá el resultado que se indica a continuación cuando se ejecute en compiladores GCC:
Inside main()c>
Esto sucede porque GCC no admite el inicio o la salida de #pragma. Sin embargo, puede utilizar el siguiente código para obtener el resultado esperado en los compiladores GCC.
C
velocidad de baudios en arduino
#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;> }> |
>
>Producción
Inside func1() Inside main() Inside func2()>
En el programa anterior, hemos utilizado algunos sintaxis específicas de modo que una de las funciones se ejecute antes de la función principal y la otra se ejecute después de la función principal.
#pragma directiva de advertencia
Esta directiva se utiliza para ocultar el mensaje de advertencia que se muestra durante la compilación. Podemos ocultar las advertencias como se muestra a continuación:
- #pragma advierte -rvl : Esta directiva oculta las advertencias que se generan cuando una función que se supone que debe devolver un valor no devuelve un valor.
- #pragma advierte -par : Esta directiva oculta las advertencias que se generan cuando una función no utiliza los parámetros que se le pasan.
- #pragma advierte -rch : Esta directiva oculta las advertencias que aparecen cuando no se puede acceder a un código. Por ejemplo, cualquier código escrito después del devolver La declaración en una función es inalcanzable.
Si te gusta techcodeview.com y te gustaría contribuir, también puedes escribir un artículo usando . Vea su artículo que aparece en la página principal de techcodeview.com y ayude a otros geeks. Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema discutido anteriormente.