Advertencias de "parámetros no utilizados" en C

gcc gcc-warning

Question

Cuál es la mejor manera de suprimir la advertencia de parámetros no utilizados en el código C.

Por ejemplo,

Bool NullFunc(const struct timespec *when, const char *who)
{
   return TRUE;
}

En C ++ pude poner un comentario /*...*/ sobre los parámetros. Pero no en C por supuesto.

Me da error: parameter name omitted .

Answer 1

Con gcc con el atributo no utilizado:

int foo (__attribute__((unused)) int bar) {
    return 0;
}

Answer 2

En MSVC para suprimir una advertencia particular, basta con especificar el número al compilador como / wd #. Mi CMakeLists.txt contiene dicho bloque:

If (MSVC)
    Set (CMAKE_EXE_LINKER_FLAGS "$ {CMAKE_EXE_LINKER_FLAGS} / NODEFAULTLIB: LIBCMT")
    Add_definitions (/W4 /wd4512 /wd4702 /wd4100 /wd4510 /wd4355 /wd4127)
    Add_definitions (/D_CRT_SECURE_NO_WARNINGS)
Elseif (CMAKE_COMPILER_IS_GNUCXX OR CMAKE_COMPILER_IS_GNUC)
    Add_definitions (-Wall -W -pedantic)
Else ()
    Message ("Unknown compiler")
Endif ()

Ahora no puedo decir qué significa exactamente / wd4512 / wd4702 / wd4100 / wd4510 / wd4355 / wd4127, porque no le presto ninguna atención a MSVC durante tres años, pero suprimen las advertencias superpendidas que no influyen en el resultado.

Answer 3

En gcc, puede etiquetar el parámetro con el atributo unused .

Este atributo, asociado a una variable, significa que la variable está destinada a ser posiblemente no utilizada. GCC no generará una advertencia para esta variable.

En la práctica esto se logra poniendo __attribute__ ((unused)) justo después del parámetro. Por ejemplo

auto lambda = [](workerid_t workerId) -> void { };

se convierte

auto lambda = [](__attribute__((unused)) _workerid_t workerId) -> void { } ;

Answer 4

Etiquetar el atributo es la forma ideal. MACRO lleva a confusión en algún momento. y al usar void (x), estamos agregando una sobrecarga en el procesamiento.

Si no usa el argumento de entrada, use

void foo(int __attribute__((unused))key)
{
}

Si no usa la variable definida dentro de la función

void foo(int key)
{
   int hash = 0;
   int bkt __attribute__((unused)) = 0;

   api_call(x, hash, bkt);
}

Ahora, más adelante, usa la variable hash para tu lógica pero no necesita bkt. define bkt como no utilizado, de lo contrario el compilador dice ''bkt set bt not used ".

NOTA: Esto es solo para suprimir la advertencia, no para la optimización.

Answer 5

He visto este estilo ser utilizado:

if (when || who || format || data || len);

Answer 6

Normalmente escribo una macro como esta:

#define UNUSED(x) (void)(x)

Puede usar esta macro para todos sus parámetros no utilizados. (Tenga en cuenta que esto funciona en cualquier compilador).

Por ejemplo:

void f(int x) {
    UNUSED(x);
    ...
}

Answer 7

Para el registro, me gusta la respuesta de Job anterior, pero tengo curiosidad acerca de una solución que solo utiliza el nombre de la variable por sí mismo en una declaración de "no hacer nada":

void foo(int x) {
    x; /* unused */
    ...
}

Claro, esto tiene inconvenientes; por ejemplo, sin la nota "sin usar" parece un error en lugar de una línea intencional de código.

El beneficio es que no se necesita DEFINE y se deshace de la advertencia.

¿Hay algún rendimiento, optimización u otras diferencias?

Answer 8

Puede usar el atributo no utilizado de gcc / clang, sin embargo, uso estas macros en un encabezado para evitar tener atributos específicos de gcc en toda la fuente, también tener __attribute__ todas partes es un poco verboso / feo.

#ifdef __GNUC__
#  define UNUSED(x) UNUSED_ ## x __attribute__((__unused__))
#else
#  define UNUSED(x) UNUSED_ ## x
#endif

#ifdef __GNUC__
#  define UNUSED_FUNCTION(x) __attribute__((__unused__)) UNUSED_ ## x
#else
#  define UNUSED_FUNCTION(x) UNUSED_ ## x
#endif

Entonces puedes hacer ...

void foo(int UNUSED(bar)) { ... }

Prefiero esto porque obtienes un error si tratas de usar la bar en el código en cualquier lugar para que no puedas dejar el atributo por error.

y para funciones ...

static void UNUSED_FUNCTION(foo)(int bar) { ... }

Nota 1):
Hasta donde yo sé, MSVC no tiene un equivalente a __attribute__((__unused__)) .

Nota 2):
La macro UNUSED no funcionará para argumentos que contengan paréntesis,
entonces si tienes un argumento como float (*coords)[3] no puedes hacer,
float UNUSED((*coords)[3]) o float (*UNUSED(coords))[3] , este es el único inconveniente de la macro UNUSED he encontrado hasta ahora, en estos casos recurro a (void)coords;

Answer 9

Tengo el mismo problema. Usé una biblioteca de terceros. Cuando compilo esta biblioteca, el compilador (gcc / clang) se quejará de las variables no utilizadas.

Me gusta esto

test.cpp: 29: 11: warning: variable ''magic'' establecida pero no utilizada [-Wunused-but-set-variable] short magic [] = {

test.cpp: 84: 17: warning: variable no utilizada ''before_write'' [-Wunused-variable] int64_t before_write = Thread :: currentTimeMillis ();

Entonces la solución es bastante clara. Añadiendo -Wno-unused como gcc / clang CFLAG suprimirá todas las advertencias "sin usar", incluso si usted tiene -Wall establecido.

De esta forma, NO NECESITA cambiar ningún código.

Answer 10

Una forma específica de gcc / g ++ de suprimir la advertencia de parámetro no utilizada para un bloque de código fuente es encerrarlo con las siguientes sentencias pragma:

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
<code with unused parameters here>
#pragma GCC diagnostic pop