Definición de macro de tipo función en C

Question

Me gustaría definir una función como MACRO. es decir,

#define foo(x)\ 
#if x>32\ 
x\ 
#else\ 
(2*x)\ 
#endif 

que es,

if x>32, then foo(x) present x 
else, foo(x) present (2*x) 

pero mi queja de GCC:

int a = foo(31); 

creo preprocesador de C debe ser manejar esto correctamente. ya que en tiempo de compilación, conoce x=33. se podría sustituir con foo(33)(2*33)

Answer 1

considerar:

int x = rand() 
int y = foo(x); 

x no se conoce en tiempo de compilación.

Answer 2

Puede la siguiente manera

#define foo(x) ((x) > 32 ? (x) : (2 * (x))) 

Pero que evalúa x varias veces. En su lugar puede crear una función estática, lo que es más limpio

static int foo(int x) { 
    if(x > 32) 
    return x; 
    return 2 * x; 
} 

A continuación, también son capaces de pasar a cosas foo que tienen efectos secundarios, y tienen el efecto secundario ocurre sólo una vez.

lo que ha escrito es el uso de los #if, #else y #endif directivas del preprocesador, pero hay que usar construcciones del lenguaje si pasar variables a la macro y desea evaluar sus valores. El uso de if y las declaraciones else como en las construcciones de lenguaje reales tampoco funcionan, porque las instrucciones de flujo de control no evalúan los valores. En otras palabras, una instrucción if solo controla el flujo de control ("si A, luego ejecuta B, sino ejecuta C"), sin evaluar a ningún valor.

Answer 3

int a = foo(31); 

expande a

int a = if 31>32 
31 
else 
(2*31) 
endif; 

Así es como funcionan las macros C, a través de la sustitución simple, tonto. Si espera que GCC haga algo más complejo o inteligente con ellos, entonces su expectativa es errónea.

Dado que es fácil ver por qué su código no funcionará. Una alternativa que sería suficiente para este ejemplo sería:

#define foo(x) (x > 32 ? x : 2*x) 

Por otro lado, me pregunto si las macros son realmente la herramienta apropiada para tal cosa, para empezar. Simplemente póngalo en la función y el compilador insertará el código si cree que lo acelerará.

Answer 4

El problema no es sobre la teoría: siempre que, por alguna razón, desee tener una macro que se expanda de manera diferente según el valor de un parámetro que se le pase, y este parámetro es una constante, conocida por la macro preprocesador, no hay ninguna razón por la que no podría funcionar ... para un macroprocesador genérico ... Pero desafortunadamente, cpp no ​​permite la presencia de otros "comandos" de macroprocesador en una definición de macro ...

Así que su

#define foo(x) \ 
#if x>32 \ 
    x  \ 
#else \ 
    2*x \ 
#endif 

no se expande a

#if X>32 
    X 
#else 
    2*X 
#endif 

donde X es el parámetro conocido (por lo que cambiar X a, por ejemplo 31), que requiere otro pase por el preprocesador.

Además, las nuevas líneas se ignoran, aunque son importantes para dicho uso; de lo contrario, el siguiente podría ser considerado como un truco (que necesitan otro paso de procesamiento previo, sin embargo)

#define foo(x,y) \ 
y if x>32 \ 
    x \ 
y else \ 
    2*x \ 
y endif 

que con foo(20,#) produce

# if 20>32 20 # else 2*20 # endif 

que funciona, si sería

# if 20>32 
    20 
# else 
    2*20 
# endif 

... pero no es (y como se dijo, la salida del preprocesador debe ser alimentada al preprocesador nuevamente ...)

Así que mi respuesta es que si necesita estas cosas, no puede usar el preprocesador C; debería usar un preprocesador C poco común (¿no estándar?), o simplemente otro macroprocesador, y si necesita el tipo de cosas que "cpp" tiene que "integrarse" con C, entonces no puede usar una genérica (como M4) tan fácilmente ...

Answer 5

#define \ 
    foo(x) \ 
    ({ \ 
     int xx = (x); \ 
     int result = (xx > 32) ? xx : (2*xx); \ 
     result; \ 
    })