Macros en C. MIS. Lizbeth Alejandra Hernández González Programación de Sistemas

Transcripción

1 Macros en C MIS. Lizbeth Alejandra Hernández González Programación de Sistemas

2 Macros en C Usa un preprocesador de macros Remueve todos los comentarios del código fuente Efectúa una serie de sustituciones conceptuales basadas en el código pasando el resultado al compilador.

3 1. # include <stdio.h> # define INICIO 0 /* Punto de inicio del bucle */ 4. # define FINAL 9 /* Fin del bucle */ 5. # define MAX(A,B) ((A)>(B)?(A):(B)) /* Definición macro de Max */ 6. # define MIN(A,B) ((A)>(B)?(B):(A)) /* Definición macro de Min */ int main( ) 9. { 10. int indice, mn, mx ; 11. int contador = 5 ; for (indice = INICIO ; indice <= FINAL ; indice++) 14. { 15. mx = MAX(indice, contador) ; 16. mn = MIN(indice, contador) ; 17. printf ( "Max es %d y min es %d\n", mx, mn) ; 18. } 19. return 0 ; 20. }

4 Resultado de la ejecución: Max es 5 y min es 0 Max es 5 y min es 1 Max es 5 y min es 2 Max es 5 y min es 3 Max es 5 y min es 4 Max es 5 y min es 5 Max es 6 y min es 5 Max es 7 y min es 5 Max es 8 y min es 5 Max es 9 y min es 5

5 #define es la manera para declarar todas las macros y definiciones. el compilador va a la etapa del preprocesador para resolver todas las definiciones, P.e. se buscará cada lugar en el programa donde se encuentre la palabra INICIO y será reemplazada con un cero El compilador en sí jamás verá la palabra INICIO. Es una práctica común en C utilizar mayúsculas para constantes simbólicas y minúsculas para variables.

6 cada vez que el preprocesador encuentra la palabra MAX (termino1, termino2) espera encontrar dos términos el primer término reemplazará cada A en la segunda parte de la definición, y el segundo término reemplazará cada B en la segunda parte de la definición. línea 15, indice será sustituída por cada A, y contador será sustituida por cada B.

7 antes de que la línea 15 sea entregada al compilador, será modificada: Definición: # define MAX(A,B) ((A)>(B)?(A):(B)) 15 mx = MAX(indice, contador) ; 15 mx = ((index)>(count)? (index) : (count))

8 Una macro equivocada #define EQUIVOCADA(A) A*A*A /* Macro EQUIVOCADA para el cubo */ #define CUBO(A) (A)*(A)*(A) /*Macro correcta para el cubo */ #define CUADRADO(A) (A)*(A) /* Macro correcta para el cuadrado */ #define SUMA_EQUIVOCADA(A) (A)+(A) // Macro equivocada para la suma #define SUMA_CORRECTA(A) ((A)+(A)) /* Macro correcta para la suma */ #define INICIO 1 #define FINAL 7

9 int main( ) { int i, offset ; offset = 5 ; for (i = INICIO ; i <= FINAL ; i++) { printf ("El cuadrado de %3d es %4d, y su cubo es %6d\n", i+offset, CUADRADO(i+offset), CUBO(i+offset)) ; printf ("El cubo equivocado de %3d es %6d\n", i+offset, EQUIVOCADA(i+offset)) ; } printf ("\nprobamos la macro de suma\n") ; for (i = INICIO ; i <= FINAL ; i++) { printf ("La macro de suma EQUIVOCADA = %6d, y la correcta = %6d\n", 5*SUMA_EQUIVOCADA(i), 5*SUMA_CORRECTA(i)) ; } return 0 ; }

10

11 Necesidad de paréntesis Los paréntesis son necesarios para agrupar adecuadamente las variables. Si i es 1 esperamos el cubo de (1+5=6) = 216 Cuando se usa CUBO(A) (A)*(A)*(A) (1+5)*(1+5)*(1+5) = 6*6*6 = 216. Cuando se usa EQUIVOCADA(A) A*A*A 1+5*1+5*1+5 = = 16 resultado erróneo.

12 Suma equivocada #define SUMA_EQUIVOCADA(A) (A)+(A) #define SUMA_CORRECTA(A) ((A)+(A)) 5*SUMA_EQUIVOCADA(i) con i=1, resultado 5* = 6, el resultado esperado era 5*(1+1) = 5*2 = 10 usando SUMA_CORRECTA, esto se debe a los paréntesis extra NOTA: Agregar paréntesis a cada término y a cada expresión (corregir CUBO)

13 Compilación condicional 1. #include <stdio.h> 2. #include <stdlib.h> 3. # define OPCION_1 /* Esto define el control del preprocesador */ 4. //# undef OPCION_1 5. # ifdef OPCION_1 6. int contador_1 = 17; /* Esto existe solo si OPCION_1 es definido */ 7. # endif 8. int main( ) 9. { 10. int indice ; 11. for (indice = 0 ; indice < 6 ; indice++) 12. { 13. printf ("En el bucle, indice = %d", indice) ; 14. # ifdef OPCION_1 15. printf (" contador_1 = %d", contador_1) ; /* puede desplegarse */ 16. # endif 17. printf ("\n") ; 18. } 19. system("pause"); 20. return 0 ; 21. } 22. # undef OPCION_1

14 Pruebe el programa Cuál es la salida? Comente la línea 3 Cuál es la salida? Descomente la línea 3 y descomente la línea 4 Cuál es la salida?

15 Ifndef 1. #include <stdio.h> 2. #include <stdlib.h> "si no definido". 3. # define OPCION_1 /* Esto define el control al preprocesador */ 4. # define MUESTRA_DATO /* Si es definido, se muestra*/ 5. # ifndef OPCION_1 6. int contador_1 = 17; /* Esto existe si OPCION_1 no es definido */ 7. # endif 8. int main( ) 9. { 10. int indice ; 11. # ifndef MUESTRA_DATO 12. printf ("MUESTRA_DATO no está definido en el codigo\n") ; 13. # endif 14. for (indice = 0 ; indice < 6 ; indice++) 15. { 16. # ifdef MUESTRA_DATO 17. printf ("En el bucle, indice = %d", indice) ; 18. # ifndef OPCION_1 19. printf (" contador_1 = %d", contador_1); /* Esto puede mostrarse*/ 20. # endif 21. printf ("\n") ; 22. # endif 23. } 24. system("pause"); 25. return 0 ; 26. }

16 Correr el programa Verificar la salida original Verificar la salida comentando la línea 3

17 Procesador de macros M4

18 Procesador de macros M4 Funciona como el procesador de macros de C. Utiliza un lenguaje de macros diferente y de propósito general; lo cual resulta más potente. Ejecutar m4 sin argumentos: el comando espera texto por la entrada estándar, tras cada línea introducida, ésta se procesa y se imprime el resultado por la salida estándar. También puede recibir archivos

19 La mayor utilidad que se le ha dado a M4 ha sido en las famosas autotools de GNU (autoconf, automake, etc.) Otro ejemplo es utilizar M4 para escribir páginas web (creando una abstracción por encima del HTML).

20 Utilización de macros Llamada a macros: 1. CANTINFLAS 2. Hola señor CANTINFLAS 3. Hola señor CANTINFLAS()puntoycoma. 4. Hola señor CANTINFLAS(punto, y, coma). 5. Hola señor CANTINFLAS(punto y coma).

21 La macro que nos permite definir nuevas macros: define admite dos argumentos: el nombre de la nueva macro y el texto por el que será reemplazada cada aparición de dicha macro: define(`cantinflas', 'Bigote') define(`bold', `<b>$1</b>') Ej. BOLD(hola) será substituido por <b>hola</b> define(hola, Hola mundo cruel) $0 que se expande como el nombre de la macro

22 Otros modificadores $* expande todos los argumentos separados por comas. hace lo mismo pero además quotea el resultado para evitar expansiones del mismo. $# se expande como el número de argumentos pasados a la macro.

23 Comentarios dnl Comentario que no aparecerá en el resultado. # Comentario que sí aparecerá en el resultado

24 Cadenas protegidas Cuando hablamos de una expansión nos referimos a dos cosas: Expandir una macro o Si se trata de un texto rodeado por ` ' simplemente se eliminan las comillas. el proceso de expansión de una macro es recursivo: 1. Expansión de los argumentos. 2. Se procede a la substitución del texto. 3. Se vuelve a procesar el resultado de esta expansión.

25 Saber proteger el texto quoteándolo. Para la inclusión de cadenas literales en el argumento de una macro basta con rodearla de comillas dobles, p.e.: define(`cantinflas', `$1') Hola señor CANTINFLAS(``Y esto aparece tal cual, metamos lo que metamos' )

26 Si necesitamos que una macro se expanda entre texto que no está separado por espacios podemos usar la cadena vacía `'. Por ejemplo: esecantinflaspoderoso (no válido) ese`'cantinflas`'poderoso anti`'cantinflas() M4 tiene macros para implementar condicionales, como ifdef e ifelse