Las macros se convierten en constantes antes de compilar. No ocupan memoria ni tiempo de ejecución.
Esa es la parte buena de las macros.
Un saludo.
No entiendo como... un macro utiliza "variables", por lo que no se puede calcular antes de compilar. A menos que sea un macro utilizado solo para constantes definidas.
No, no son variables, es texto, el preprocesador trabaja con texto.
#define UNA_MACRO_CON_ARGUMENTO(ARG) ((ARG)*5 - 12)
Hace de cuenta que cuando invocas
algunaVariable = UNA_MACRO_CON_ARGUMENTO(40);
El pre-procesador de C hace un buscar/reemplazar, busca primero UNA_MACRO_CON_ARGUMENTO, y donde decía ARG ahora reemplaza con 40
algunaVariable = ((40)*5 - 12);
El pre-procesador se ejecuta antes del compilador, hace esos reemplazos, y luego se llama al compilador.
Luego si yo la uso mal y escribo:
algunaVariable = UNA_MACRO_CON_ARGUMENTO("prrrffff");
el pre-procesador va a poner
algunaVariable = (("prrrffff")*5 - 12);
y el compilador no va a entender nada y quejarse en la línea de código anterior.
Pero si defino mal la macro, por ejemplo cometo un error de tipeo:
#define UNA_MACRO_CON_ARGUMENTO(ARG) ((ATG)*5 - 12)
algunaVariable = UNA_MACRO_CON_ARGUMENTO(40);
ahora se convierte en:
algunaVariable = ((ATG)*5 - 12);
el compilador se va a preguntar donde está ATG y va a marcar error en la línea de algunaVariable, y NO en la definición de la macro.
Muchas veces me pasó que uso alguna macro, el compilador informa de error en la línea tal (que claro, la línea es una llamada a una función que toma un argumento que se saca de una macro que a su vez llama a otra función que hace un typecasting...) y uno pierde horas buscando errores en funciones cuando el problema era una macro mal definida.
NO hay chequeo de error de macros, es decir, a nivel pre-procesador. Y por eso se dice que una macro es "parecida" a una función, pero no lo es porque como ya mencionaron no genera código, ni tampoco hay chequeo de errores.
Y es solo eso, un reemplazo textual (un buscar-reemplazar), que puede ser mucho más complicado con varias líneas y varias pasadas.
Con pasadas me refiero a:
#define ECUACION_RECTA(pendiente, offset, valor) (pendiente * valor + offset)
#define ADC_PENDIENTE(ref_mv, resolucionBits) (ref_mv/ (2^resolucionBits-1) )
#define CUENTAS_ADC_A_MV(valorADC) ECUACION_RECTA(ADC_PENDIENTE(2500,10), 0, valorADC)
Esta última línea "diría" que uso un conversor de 10 bits con una referencia de 2,5V (2500mV).
Entonces si escribo
variable = CUENTAS_ADC_A_MV(registroADC) ;
primero el preprocesador hace (pasada 1):
variable = ECUACION_RECTA(ADC_PENDIENTE(2500,10), 0, registroADC);
luego (pasada 2):
variable = ECUACION_RECTA((2500/ (2^10-1) ), 0, registroADC);
y por último (pasada 3):
variable = ( (2500/ (2^10-1) ) * registroADC + 0);
Bueno, seguro hay errores pero yo hago como el preprocesador y no chequeo nada
¿Pero creo que la idea se ve?