c++ - Suprimir Función de advertencia del compilador declarada nunca referenciada

gcc gcc-warning

Question

Así que tengo un código como este:

void foo (int, int);

void bar ( )
{
    //Do Stuff

   #if (IMPORTANT == 1)
       foo (1, 2);
   #endif

}

Cuando hago una compilación sin "IMPORTANTE" obtengo un compilador. Advertencia de que foo está definido y nunca se hace referencia. Lo que me hizo pensar (ese es el problema).

Entonces, para solucionar este problema, acabo de agregar el mismo #if (IMPORTANT == 1) alrededor de la definición de la función, etc ... para eliminar la advertencia, y luego comencé a preguntarme si había una manera diferente de suprimir esa advertencia en esa función. ¿Estaba buscando un atributo GCC "sin usar" y no sabía si las funciones tenían el mismo atributo que podía establecer? ¿Hay alguna otra forma de suprimirlo que suprima esa advertencia solo para esa función y no para el archivo?

Answer 1

... luego comencé a preguntarme si había una forma diferente de suprimir esa advertencia en esa función.

Puede haber opciones del compilador para suprimir esta advertencia. Sin embargo, un truco es este:

(void)foo; //don''t call the function, just use it as function-pointer

Debería suprimir esta advertencia.

Podrías escribir una macro:

#define SUPPRESS_WARNING(a) (void)a

void foo(int thisIsAlsoAnUnsedParameter, int usedParameter)
{
   SUPPRESS_WARNING(foo); //better do this inside the definition itself :D

   SUPPRESS_WARNING(thisIsAlsoAnUnsedParameter);
}

Como puede ver, la definición de foo suprime la advertencia.

Answer 2

En C ++ 17 puede declarar su función con [[maybe_unused]] :

[[maybe_unused]] void foo (int, int);

Esto suprimirá la advertencia y es la forma correcta e idiomática de expresar una función posiblemente no utilizada en C ++ 17.

Answer 3

Encuentro una forma de hacer eso globalmente y funciona también en c

#define SUPPRESS_UNUSED_WARN(var) /
    int _dummy_tmp_##var = ((int)(var) & 0)

entonces lo usas como:

static int foo(int a, int b)
{
    // ....
}
SUPRESS_UNUSED_WARN(foo);

• Se puede utilizar en funciones y variables globales.
• Se debe colocar globalmente para trabajar.
• No se puede usar para variables locales.

Answer 4

Estoy bastante seguro de que la opción de advertencia relevante es esta:

Función
Avisar cada vez que se declara una función estática pero no está definida o una función estática no en línea no se utiliza. Esta advertencia está habilitada por -Wall.

Así que la advertencia solo debe darse para una función static , interesante. Tiene sentido. Si una función es static , solo se puede utilizar dentro del archivo actual, por lo que su definición también debe estar en este archivo.

Y declararlo static inline evita la advertencia, sin recurrir a macros feas o pragmas o atributos específicos del compilador.

Answer 5

Para la plataforma de destino ARM mientras usa el compilador ARM, use la siguiente directiva del compilador alrededor de la función de destino para suprimir los mensajes de advertencia:

#pragma diag_suppress 177
void foo(void)
{
/* does something but is not being called for the current build */
}

Answer 6

También puede definir la macro _CRT_SECURE_NO_DEPRECATE en la configuración del proyecto de Visual Studio.

Ir a Propiedades del proyecto -> Propiedades de configuración -> C / C ++ -> Preprocesador -> Definiciones de preprocesador

Agregue _CRT_SECURE_NO_DEPRECATE.

Eso es.!

Answer 7

Una buena manera de encapsular cosas dependientes del compilador y del sistema es factorizarlo en encabezados. Luego, ajusta la ruta de inclusión según el compilador y el sistema, y ​​quizás otras cosas. Puedes hacer lo mismo para los archivos de código fuente.

En este caso, la declaración no parece depender del compilador o del sistema, así que solo agregue el siguiente encabezado común:

// [foo.h]
#pragma once
void foo( int, int );

Con archivo de implementacion

// [foo.cpp]
#include <foo.virtual.cpp>

Luego, para la compilación donde debería suceder algo, agregue a la ruta de inclusión un directorio que contenga

// [foo.virtual.cpp]
#include <foo.h>
void foo( int const a, int const b )
{
    // Do the thing.
}

Y para la compilación donde no debería ocurrir nada, agregue a la ruta de inclusión un directorio que contenga

// [foo.virtual.cpp]
#include <foo.h>
void foo( int, int ) {}

Si tiene miedo de que la llamada de una función vacía lleve mucho tiempo, como, un nano-segundo perdido, simplemente mueva las definiciones a los encabezados y agregue la palabra en inline .

Si foo también se usa para otros propósitos, defina una bar funciones que la llame para lo que debería o no debería ocurrir, y haga lo anterior para la bar lugar de para foo .

Luego, has eliminado todas las cosas del preprocesador.

Recuerde que las directivas de preprocesador en código no son correctas.

Answer 8

Una solución es a través de atributos de función.

void foo (int, int) __attribute__ ((unused));

Esto le indicará a gcc que no emita una advertencia de función no utilizada para la función foo . Si le preocupa la portabilidad, puede definir una macro UNUSED_FUNCTION_ATTRIBUTE que se expande a __attribute__ ((unused)) con compiladores que admiten atributos, pero no se expande a nada.