Ignorar los valores devueltos en C

Personalmente me gustan las advertencias "no utilizadas", pero en ocasiones hay casos en los que tengo que ignorarlas (por ejemplo, el write() al usuario, o fscanf(...,"%*s\n") o strtol() donde el valor devuelto no es importante y solo quiero el efecto secundario de [tal vez] mover el puntero del archivo.)

Con gcc 4.6, se está volviendo bastante complicado.

• La fundición a (void) ya no funciona.
• Reescribir funciones (especialmente variádicas) es tedioso y torpe.
• {ssize_t ignore; ignore=write(...);} lanza otra advertencia (asignado-no-usado).
• write(...)+1 lanza otra advertencia (valor computado-no-usado).

La única manera buena (aunque fea) de suprimir esto es convertir el valor devuelto en algo que el compilador está de acuerdo en que se puede ignorar.

Por ejemplo, (void)(write(...)+1).

Esto es aparentemente progreso. (Y +0 no funciona, POR cierto.)

Una forma de hacer esto con los compiladores Clang y GCC es con un pragma:

    /* ... */

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-result" 

    foo(); /* this specific unused-result warning gets ignored during compilation */

#pragma GCC diagnostic pop 

    /* ... */

El push-pop combination envuelve la directiva ignored para que las advertencias puedan activarse en cualquier parte del código. Debería ser más fácil para cualquiera que lea su código fuente en el futuro ver lo que hace este bloque de código.

Para que un comprobador de código estático sea útil, debe informar también de los valores de retorno ignorados, lo que puede conducir muy a menudo a errores difíciles de rastrear, o a la falta de manejo de errores.

Por lo que debe mantener el (void) o desactivar la comprobación de printf. Ahora tienes varias opciones para hacerlo de una manera legible. Uso para envolver la función dentro de una nueva función como por ejemplo

void printf_unchecked(const char* format, ...)

Donde tiene lugar el reparto no tan agradable. Tal vez sea más práctico hacerlo usando un macro preprocesador en este caso debido a los varargs...

Una forma un poco más "hermosa" de indicar los resultados no utilizados sería esta:

/**
 * Wrapping your function call with ignore_result makes it more clear to
 * readers, compilers and linters that you are, in fact, ignoring the
 * function's return value on purpose.
 */
static inline void ignore_result(long long int unused_result) {
    (void) unused_result;
}

...

ignore_result(foo());

Con C++, esto puede extenderse a:

template<typename T>
inline void ignore_result(T /* unused result */) {}

Me gusta compilar mis códigos con las banderas:

$gcc prog1.c -o prog1.x -Wall -Wextra -ansi -pedantic-errors -g -O0 -DDEBUG=1

Y para evitar -Wunused-result no me gusta la idea de agregar otra bandera: -Wno-unused-result (si lo haces, esa es una solución).

Solía usar (void) para algunas funciones (no printf u otras famosas, ya que los compiladores no advierten sobre ellas, solo las extrañas). Ahora lanzar a (void) ya no funciona (GCC 4.7.2)

Divertida férula aconseja:

Result returned by function call is not used. If this is intended,
can cast result to (void) to eliminate message. (Use -retvalother to
inhibit warning)

Pero esto ya no es una solución. Tablilla necesita una actualización en relación con este tema.

Por lo tanto, para deshacerse de la advertencia de una manera muy compatible, aquí hay una buena MACRO:

/** Turn off -Wunused-result for a specific function call */
#define igr(M) if(1==((int)M)){;}

Y llámalo así: {[26]]}

igr(PL_get_chars(t, &s, CVT_VARIABLE));

Es un aspecto limpio, y cualquier compilador eliminará el código. A continuación una imagen de mi editor preferido vi: ventana izquierda, no igr(); ventana central, usando igr(); ventana derecha, fuente.

Puedes ver, es exactamente el mismo, un código completamente inocuo que permite a C hacer lo que gcc no permite: ignorar el código de devolución.

La comparación 1==... solo es necesaria para evitar la advertencia de tablilla de que este condicional es no BOOL. A GCC no le importa. Dependiendo de la función, puede recibir una advertencia cast. Hice una prueba ignorando un double con esta MACRO y fue bueno, pero de alguna manera no estoy completamente convencido. Especialmente si la función devuelve un puntero o algo más complejo.

En este caso también necesitará:

#define pigr(M) if(NULL==((void *)M)){;}

Última cosa: el {;} es necesario debido a la advertencia -Wempty-body (sugerir llaves alrededor del cuerpo vacío en una sentencia 'if').

Y (ahora lo último) el ; después de la llamada a la función no es (estrictamente) necesario, sino su buena práctica. Hace que sus líneas de código sean más homogéneas, todas terminan en un ;. (Se traduce como NOP mnemónico, y después de la optimización, desaparecer).

Ejecutar el compilador no da ninguna advertencia o error. Runing splint da:

$ splint ./teste.c -I/usr/lib/swi-prolog/include/ -strict-lib
Splint 3.1.2 --- 20 Feb 2009

Finished checking --- no warnings

Véase también este respuesta

Gnulib tiene esto: http://git.savannah.gnu.org/cgit/gnulib.git/tree/lib/ignore-value.h

/* Normally casting an expression to void discards its value, but GCC
   versions 3.4 and newer have __attribute__ ((__warn_unused_result__))
   which may cause unwanted diagnostics in that case.  Use __typeof__
   and __extension__ to work around the problem, if the workaround is
   known to be needed.  */
#if 3 < __GNUC__ + (4 <= __GNUC_MINOR__)
# define ignore_value(x) \
    (__extension__ ({ __typeof__ (x) __x = (x); (void) __x; }))
#else
# define ignore_value(x) ((void) (x))
#endif

Normalmente no hay demasiadas funciones cuyo valor se quiera ignorar. Splint, por ejemplo, permite agregar un comentario especial que le haría saber, que un valor devuelto de una función específica podría ser ignorado. Desafortunadamente, esto en efecto deshabilita todas las advertencias de 'valor devuelto ignorado' relacionadas con esa función en particular.

Aquí hay un ejemplo del programa Splint-clean :

#include <stdio.h>

FILE /*@alt void@*/ *fopen(const char *path, const char *mode);

static int /*@alt void@*/ test(void)
{
   printf( "test called\n" );

   fopen( "test", "a" );

   return 0;
}

int main(void)
{  
   test();

   return 0;
}

La parte desagradable es que necesita agregar un adicional prototype a una función del sistema con un comentario en alguna parte.

Por cierto,por defecto Splint no se queja de que el valor de retorno de printf y de algunas otras funciones libc no estén en uso. Sin embargo, se puede activar un modo más estricto.

PELUSA permite algo similar, pero nunca lo he usado. Esto es lo que dice una documentación.

LINT le permite marcar funciones con valores de retorno opcionales mediante un directiva similar a las directivas #del preprocesador C.

#pragma optresult

Se puede colocar inmediatamente antes de la definición de una función que devuelve un resultado opcional. PELUSA entonces reconoce que esta función devuelve un resultado que puede ser ignorado; LINT no da error mensajes si el resultado es ignorado.

Otra solución sería utilizar realmente un valor. Luego podría eliminar la advertencia unused variable con una macro.

#define _unused(x) ((void)(x))

Entonces en tu ejemplo, tendrías:

val = foo();
_unused(val); 

Es totalmente legal y aceptable escribir código que ignora el valor devuelto en algunos casos. El siguiente programa tiene muy pocas razones para comprobar el valor devuelto de printf().

int main(void) {
  printf("Hello world\n");
  return 0;
}