¿Cómo envolver printf() en una función o macro?

Esto puede sonar como una pregunta de entrevista, pero en realidad es un problema práctico.

Estoy trabajando con una plataforma integrada y solo tengo disponibles los equivalentes de esas funciones:

• imprimirf()
• snprintf()

Además, el printf() Es probable que la implementación (y la firma) cambien en un futuro cercano, por lo que las llamadas deben residir en un módulo separado para que sea fácil de migrar más adelante.

Dado eso, ¿puedo envolver las llamadas de registro en alguna función o macro? El objetivo es que mi código fuente llame THAT_MACRO("Number of bunnies: %d", numBunnies); en mil lugares, pero las llamadas a las funciones anteriores se ven solo en un solo lugar.

Compilador: arm-gcc -std=c99

Editar: solo por mencionar, pero las mejores prácticas posteriores a 2000 y probablemente mucho antes, las funciones en línea son mucho mejores que las macros por numerosas razones.

Hay 2 formas de hacer esto:

1. macro variadrica

   #define my_printf(...) printf(__VA_ARGS__)
   

2. función que reenvía va_args

   #include <stdarg.h>
   #include <stdio.h>
   
   void my_printf(const char *fmt, ...) {
       va_list args;
       va_start(args, fmt);
       vprintf(fmt, args);
       va_end(args);
   }
   

también hay vsnprintf, vfprintf y lo que se te ocurra en stdio.

Como puedes usar C99, lo envolvería en un macro variádica:

#define TM_PRINTF(f_, ...) printf((f_), __VA_ARGS__)
#define TM_SNPRINTF(s_, sz_, f_, ...) snprintf((s_), (sz_), (f_), __VA_ARGS__)

como no dijiste que tienes vprintf o algo asi Si tiene algo así, podría envolverlo en una función como la que Sergey L ha proporcionado en su respuesta.

El TM_PRINTF anterior no funciona con una lista VA_ARGS vacía. Al menos en GCC es posible escribir:

#define TM_PRINTF(f_, ...) printf((f_), ##__VA_ARGS__)

Los dos signos ## eliminan el exceso de coma delante de ellos si __VA_ARGS__ esta vacio.

Si puedes vivir con tener que envolver la llamada dos paréntesis, puedes hacerlo así:

#define THAT_MACRO(pargs)    printf pargs

Entonces úsalo:

THAT_MACRO(("This is a string: %s\n", "foo"));
           ^
           |
          OMG

Esto funciona ya que, desde el punto de vista del preprocesador, la lista completa de argumentos se convierte en un macroargumento, que se sustituye por el paréntesis.

Esto es mejor que simplemente hacer

#define THAT_MACRO printf

Ya que te permite definirlo:

#define THAT_MACRO(pargs)  /* nothing */

Esto “comerá” los argumentos de la macro, nunca serán parte del código compilado.

ACTUALIZAR Por supuesto, en C99 esta técnica es obsoleta, solo use una macro variádica y sea feliz.

#define TM_PRINTF(f_, ...) printf((f_), ##__VA_ARGS__)

los ## token habilitará el uso TM_PRINTF("aaa");

#define PRINTF(...) printf(__VA_ARGS__)

Esto funciona así:

Define la macro parametrizada PRINTF para aceptar (hasta) argumentos infinitos, luego la preprocesa desde PRINTF(...) para printf(__VA_ARGS__). __VA_ARGS__ se usa en definiciones de macros parametrizadas para denotar los argumentos dados (porque no puedes nombrar argumentos infinitos, ¿verdad?).

¿Biblioteca limitada? ¿Sistema Integrado? ¿Necesita el mayor rendimiento posible? ¡No hay problema!

Como se demuestra en esta respuesta a esta pregunta, puede usar el lenguaje ensamblador para envolver funciones que no aceptan VA_LIST en las que sí lo hacen, ¡implementando su propio vprintf a bajo costo!

Si bien esto funcionará, y es casi seguro que dará como resultado el rendimiento y la abstracción que desea, solo recomendaría que obtenga una biblioteca estándar con más funciones, tal vez cortando partes de uClibc. Tal solución seguramente será una respuesta más portátil y, en general, más útil que usar el ensamblaje, a menos que necesite absolutamente todos los ciclos.

Es por eso que tales proyectos existen, después de todo.

Esta es una versión ligeramente modificada de la excelente respuesta de @ ldav1 que imprime el tiempo antes del registro:

#define TM_PRINTF(f_, ...)                                                                            \
{                                                                                                 \
    struct tm _tm123_;                                                                            \
    struct timeval _xxtv123_;                                                                     \
    gettimeofday(&_xxtv123_, NULL);                                                               \
    localtime_r(&_xxtv123_.tv_sec, &_tm123_);                                                     \
    printf("%2d:%2d:%2d.%d\t", _tm123_.tm_hour, _tm123_.tm_min, _tm123_.tm_sec, _xxtv123_.tv_usec); \
    printf((f_), ##__VA_ARGS__);                                                                  \
};