Macro para desactivar sentencias printf

Qué MACRO se puede usar para desactivar las declaraciones de printf, en lugar de eliminarlas todas para comstackciones de implementación, solo quiero desactivarlas, omitirlas, ignorarlas.

EDITAR: Personalmente uso gcc, pero el código es parte de un proyecto más grande que se comstackrá en un tablero de Panda que ejecuta Ubuntu.

No es exactamente lo que solicita, pero uso esta construcción en mi código para la salida de depuración cuando no tengo a mano un sistema de registro adecuado:

#if 1 #define SPAM(a) printf a #else #define SPAM(a) (void)0 #endif 

Así que puedo hacer esto en todo mi código

 SPAM(("foo: %d\n", 42)); 

y luego deshabilítelos todos cambiando 1 a 0 en #if arriba.

Pero si tiene soporte de variables variadas en todos los comstackdores para los que escribe código, entonces puede buscar otras respuestas y simplemente redefinir printf . (Dicho esto, me parece útil para distintas impresiones de depuración de las copias regulares en el código, ya que usar un nombre de función diferente ayuda a mejorar la legibilidad).

Tenga en cuenta que también puede redirigir la stdout a /dev/null , pero supongo que también desea deshacerse de la sobrecarga del tiempo de ejecución.

 #ifdef IGNORE_PRINTF #define printf(fmt, ...) (0) #endif 

Consulte también la macro C #define para la impresión de depuración, que trata algunos problemas importantes estrechamente relacionados con esto.

Dos opciones, ya sea:

 #define printf(...) 

(requiere parámetros de macro variadic C99), debe colocarlo en algún archivo de encabezado común que nunca se incluya antes de stdio.h, si hay uno.

O puede decirle al vinculador que lo vincule a otra cosa, en GCC definiría

 int wrap_printf(void) {return 0;} 

y enlace usando

 --wrap printf 

Dicho todo esto, probablemente no debería usar printf para imprimir la salida de depuración, sino más bien una macro o función de utilidad (que a su vez puede usar printf si lo desea) sobre la que tiene mejor control.

Espero que ayude.

Utilizo para prefijar el debug printf () s (no todos) con PDEB.

Para las comstackciones de depuración, compilo con -DPDEB = (nada)

Para las comstackciones de lanzamiento, compilo con -DPDEB = “0 &&” o -DPDEB = “0 &&”

De esa manera, el siguiente código (test.c):

 #include  void main(void) { printf("normal print\n"); PDEB printf("debug print\n"); } 

salidas: o bien (en modo de lanzamiento): impresión normal

o bien (en modo de depuración): impresión normal impresión de depuración

Idealmente, uno podría aspirar a convertir el PDEB en la “//” (marca de comentarios), excepto que esto no es posible bajo la cadena estándar de pre / procesamiento.

Si desea evitar la advertencia potencial que la respuesta de Jonathan le puede dar y si no le importa una llamada vacía para printf , también puede hacer algo como

 #define printf(...) printf("") 

Esto funciona porque las macros de C no son recursivas. El printf("") expandido printf("") quedará solo como tal.

Otra variante (ya que estás usando gcc) sería algo como

 inline int ignore_printf(char const*, ...) __attribute__ ((format (printf, 1, 2))); inline int ignore_printf(char const*, ...) { return 0; } #define printf ignore_printf 

y en una unidad de comstackción

 int ignore_printf(char const*, ...) 

Otra posibilidad sería algo como freopen("/dev/null", "w", stdout);

Sin embargo, esto no deshabilita exactamente printf , es más o menos equivalente a ejecutar su progtwig con stdout redirigido a / dev / null, como: ./myprog > /dev/null en el indicador del shell.

He utilizado dos macros para esto. El primero define la condición para imprimir. En este sencillo ejemplo, imprimimos cada vez que el parámetro no es cero. Se pueden usar expresiones más complejas.

El segundo determina, basándose en la primera macro, llamar o no printf.

Si el comstackdor (con la configuración de optimización correcta) puede determinar la condición, no se genera ningún código.

Si la condición no se puede determinar en tiempo de comstackción, entonces será en tiempo de ejecución. Una de las ventajas de este método es que si printf no va a suceder, entonces no se evalúa a todo printf evitando muchas conversiones a cadenas que pueden suceder en una statement printf compleja.

 #define need_to_print (flag) ((flag)! = 0))

 #define my_printf (debug_level, ...) \
   ({\
     if (need_to_print (debug_level)) \
       printf (__ VA_ARGS__);  \
   })

para usarlo, llame a my_printf en lugar de printf y agregue un parámetro al principio para la condición de impresión.

 my_printf (0, "valor =% d \ n", vv);  // esto no se imprimirá
 my_printf (1, "valor =% d \ n", vv);  // esto imprimirá

 my_printf (print_debug, "value =% d \ n", vv);  // esto se imprimirá si print_debug! = 0

los (…) paréntesis que rodean la macro hacen que sea una sola statement.

#define printf // en el archivo de cabecera común. Suprimirá todo el printf .

La siguiente función simple sirve al propósito, yo uso el mismo.

 int printf(const char *fmt, ...) { return (0) }