#define y funciones con argumentos de longitud variable

Question

Tengo un trillón de llamadas de función my_printf() en un programa enorme. Ahora quiero convertirlos todos para que la función tome un nuevo argumento entero (llámalo x) sin tener que editar los trillones de llamadas. Si my_printf medida limitada a exactamente un argumento de cadena entonces yo podría hacer algo como esto:

#define my_printf(str) _my_printf(x,str) 

    void _my_printf(int x,char *str) // changed from my_printf(char *str) 
    { 
     // stuff 
    } 

Pero como my_printf toma un número variable de argumentos no estoy seguro de cómo hacerlo. Se puede hacer?

EDIT: para los que se preguntan por qué debería querer hacer una cosa así, aquí hay un ejemplo relacionado:

#if BELT_AND_BRACES_DIAGNOSTIC_MODE 
    #define function(x) _function(__FILE__,__LINE__,x) 
#else // speed critical optimised mode 
    #define function(x) _function(x) 
#endif 

#if BELT_AND_BRACES_DIAGNOSTIC_MODE 
    void _function(char *file,int line,int x) 
#else 
    void _function(int x) 
#endif 
{ 
    // stuff 
    #if BELT_AND_BRACES_DIAGNOSTIC_MODE 
    if (something_went_wrong) 
    { 
     printf("Cock up in function when called from %s line %d\n",file,line); 
    } 
    #endif 
} 

Answer 1

Es posible utilizar macros C99: variadic.

#define my_printf(...) my_printf_(x, __VA_ARGS__) 

Como Microsoft's implementation suppresse arrastran comas, el argumento str se pueden añadir de forma explícita

#define my_printf(str, ...) my_printf_(x, str, __VA_ARGS__) 

pero esto daría lugar a un error de sintaxis en C estándar cuando se invoca sin argumentos variadic

my_printf("foo") 

o un argumento vacío lista

my_printf("foo",) 

Por lo tanto, me gustaría ir con la primera versión.

Answer 2

Lo mejor es, por supuesto, hacer de tripas corazón y editar el código. De lo contrario, estás creando un "misterio" que debe ser resuelto por todos los mantenedores futuros del código. Incluso si es solo usted, este es exactamente el tipo de truco inteligente que olvidará. Es una mierda volver, y dejarse confundir por extrañas macros sin sentido.

Dicho esto, si está utilizando una cadena de herramientas de GNU, quizás pueda considerar usar varargs macros.

Answer 3

Si el código puede ser compilado como código de C99, se puede definir un variadic macro

#define my_printf(str, args...) _my_printf(x, str, ##__VA_ARGS__) 

El preprocesador sustituirá a los argumentos ... y el preprocesador GNU eliminará la coma final en caso de que se invoca la macro solo con el argumento str.

Answer 4

Si my_printf ya toma una cantidad variable de argumentos, no estoy seguro de por qué necesita envolver 'un argumento más' en una macro ... Simplemente inserte las nuevas llamadas con el argumento adicional y termine con ellas; las llamadas antiguas deberían seguir funcionando como se esperaba.

Answer 5

No con las macros estándar C89, no se puede. Sin embargo se puede obtener el mismo efecto usando funciones, rompiendo la parte principal de su función my_printf en una función vmy_printf, análogo a la norma vprintf:

#include <stdarg.h> 

int vmy_printf(int x, const char *format, va_list ap) 
{ 
    /* main body of my_printf goes here, taking its varargs from ap */ 
} 

/* new_my_printf(), for callers who know about the x parameter */ 
int new_my_printf(int x, const char *format, ...) 
{ 
    int n; 
    va_list ap; 

    va_start(ap, format); 
    n = vmy_printf(x, format, ap); 
    va_end(ap); 

    return n; 
} 

/* my_printf(), for the old callers who don't know about x */ 
int my_printf(const char *format, ...) 
{ 
    int n; 
    va_list ap; 

    va_start(ap, format); 
    n = vmy_printf(DEFAULT_X, format, ap); 
    va_end(ap); 

    return n; 
} 

(Este tipo de cosas es qué los v. .. versiones de toda la norma varargs existen funciones)

Answer 6

Una solución simple a este problema es ...

#define my_printf(x) printf x 

(tenga en cuenta los apoyos perdidos)

llamarlo, uso:

my_printf((any number of arguments)) 

(tenga en cuenta los apoyos dobles)