¿Cómo callo mejor una advertencia sobre variables no utilizadas?

Tengo una aplicación multiplataforma y en algunas de mis funciones no se utilizan todos los valores pasados ​​a las funciones. Por lo tanto, recibo una advertencia de GCC que me dice que hay variables no utilizadas.

¿Cuál sería la mejor forma de codificar la advertencia?

¿Un #ifdef alrededor de la función?

#ifdef _MSC_VER
void ProcessOps::sendToExternalApp(QString sAppName, QString sImagePath, qreal qrLeft, qreal qrTop, qreal qrWidth, qreal qrHeight)
#else
void ProcessOps::sendToExternalApp(QString sAppName, QString sImagePath, qreal /*qrLeft*/, qreal /*qrTop*/, qreal /*qrWidth*/, qreal /*qrHeight*/)
#endif
{

Esto es tan feo pero parece la forma en que el compilador preferiría.

¿O asigno cero a la variable al final de la función? (lo cual odio porque está alterando algo en el flujo del programa para silenciar una advertencia del compilador).

¿Hay una manera correcta?

Puede ponerlo en " (void)var;" expresión (no hace nada) para que un compilador vea que se usa. Esto es portátil entre compiladores.

P.ej

void foo(int param1, int param2)
{
    (void)param2;
    bar(param1);
}

O,

#define UNUSED(expr) do { (void)(expr); } while (0)
...

void foo(int param1, int param2)
{
    UNUSED(param2);
    bar(param1);
}

En GCC y Clang puedes usar la __attribute__((unused))directiva de preprocesador para lograr tu objetivo.
Por ejemplo:

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

C ++ 17 ahora proporciona el [[maybe_unused]]atributo.

http://en.cppreference.com/w/cpp/language/attributes

Bastante agradable y estándar.

Su solución actual es la mejor: comente el nombre del parámetro si no lo usa. Eso se aplica a todos los compiladores, por lo que no tiene que usar el preprocesador para hacerlo especialmente para GCC.

Actualización de C ++ 17

En C ++ 17 obtenemos el atributo [[maybe_unused]] que está cubierto en [dcl.attr.unused]

El token de atributo maybe_unused indica que un nombre o entidad posiblemente no se haya utilizado intencionalmente. Aparecerá como máximo una vez en cada lista de atributos y no habrá presente ninguna cláusula de argumento de atributo. ...

Ejemplo:

 [[maybe_unused]] void f([[maybe_unused]] bool thing1,
                        [[maybe_unused]] bool thing2) {
  [[maybe_unused]] bool b = thing1 && thing2;
    assert(b);
 }

Las implementaciones no deberían advertir que b no se utiliza, independientemente de si NDEBUG está o no definido. —Ejemplo]

Para el siguiente ejemplo:

int foo ( int bar) {
    bool unused_bool ;
    return 0;
}

Tanto clang como gcc generan un diagnóstico usando -Wall -Wextra para bar y unused_bool ( Véalo en vivo ).

Al agregar [[maybe_unused]] silencia los diagnósticos:

int foo ([[maybe_unused]] int bar) {
    [[maybe_unused]] bool unused_bool ;
    return 0;
}

ver en vivo .

Antes de C ++ 17

En C ++ 11, se UNUSEDpodría formar una forma alternativa de la macro utilizando una expresión lambda (a través de Ben Deane ) con una captura de la variable no utilizada:

#define UNUSED(x) [&x]{}()

La invocación inmediata de la expresión lambda debe optimizarse, dado el siguiente ejemplo:

int foo (int bar) {
    UNUSED(bar) ;
    return 0;
}

Podemos ver en Godbolt que la llamada está optimizada:

foo(int):
xorl    %eax, %eax
ret

Una forma aún más limpia es comentar los nombres de las variables:

int main(int /* argc */, char const** /* argv */) {
  return 0;
}

Un compañero de trabajo me acaba de señalar esta pequeña macro agradable aquí

Para facilitar, incluiré la macro a continuación.

#ifdef UNUSED
#elif defined(__GNUC__) 
# define UNUSED(x) UNUSED_ ## x __attribute__((unused)) 
#elif defined(__LCLINT__) 
# define UNUSED(x) /*@unused@*/ x 
#else 
# define UNUSED(x) x 
#endif

void dcc_mon_siginfo_handler(int UNUSED(whatsig))

gccno marca estas advertencias por defecto. Esta advertencia debe haberse activado explícitamente pasando -Wunused-parameteral compilador o implícitamente pasando -Wall -Wextra(o posiblemente alguna otra combinación de banderas).

Las advertencias de parámetros no utilizadas pueden simplemente suprimirse pasando -Wno-unused-parameteral compilador, pero tenga en cuenta que este indicador de desactivación debe aparecer después de cualquier posible indicador de habilitación para esta advertencia en la línea de comandos del compilador, para que surta efecto.

forma portátil y sin macro para declarar uno o más parámetros como no utilizados:

template <typename... Args> inline void unused(Args&&...) {}

int main(int argc, char* argv[])
{
    unused(argc, argv);
    return 0;
}

El uso de directivas de preprocesador se considera malvado la mayor parte del tiempo. Lo ideal es evitarlos como la plaga. Recuerde que hacer que el compilador comprenda su código es fácil, lo que permite que otros programadores comprendan su código es mucho más difícil. Algunas docenas de casos como este aquí y allá hacen que sea muy difícil leerlo para usted más tarde o para otros en este momento.

Una forma podría ser poner sus parámetros juntos en algún tipo de clase de argumento. Entonces podría usar solo un subconjunto de las variables (equivalente a su asignación de 0 realmente) o tener diferentes especializaciones de esa clase de argumento para cada plataforma. Sin embargo, esto podría no valer la pena, debe analizar si encajaría.

Si puede leer plantillas imposibles, puede encontrar consejos avanzados en el libro "Excepcional C ++". Si las personas que leen su código pueden obtener su conjunto de habilidades para abarcar las cosas locas que se enseñan en ese libro, entonces tendría un código hermoso que también se puede leer fácilmente. El compilador también estaría al tanto de lo que está haciendo (en lugar de ocultar todo preprocesando)

Primero, la advertencia es generada por la definición de variable en el archivo fuente, no en el archivo de encabezado. El encabezado puede permanecer impecable y debería, ya que podría estar usando algo como doxygen para generar la documentación API.

Asumiré que tiene una implementación completamente diferente en los archivos fuente. En estos casos, puede comentar el parámetro ofensivo o simplemente escribir el parámetro.

Ejemplo:

func(int a, int b)
{
    b;
    foo(a);
}

Esto puede parecer críptico, por lo que define una macro como NO UTILIZADA. La forma en que MFC lo hizo es:

#ifdef _DEBUG
#define UNUSED(x)
#else
#define UNUSED(x) x
#endif

De este modo, verá que la advertencia aún en las versiones de depuración puede ser útil.

¿No es seguro comentar siempre los nombres de los parámetros? Si no es así, puedes hacer algo como

#ifdef _MSC_VER
# define P_(n) n
#else
# define P_(n)
#endif

void ProcessOps::sendToExternalApp(
    QString sAppName, QString sImagePath,
    qreal P_(qrLeft), qreal P_(qrTop), qreal P_(qrWidth), qreal P_(qrHeight))

Es un poco menos feo.

He visto esto en lugar (void)param2de silenciar la advertencia:

void foo(int param1, int param2)
{
    std::ignore = param2;
    bar(param1);
}

Parece que esto se agregó en C ++ 11

Usar un UNREFERENCED_PARAMETER(p)podría funcionar. Sé que está definido en WinNT.h para sistemas Windows y también se puede definir fácilmente para gcc (si aún no lo tiene).

UNREFERENCED PARAMETER(p) Se define como

#define UNREFERENCED_PARAMETER(P)          (P)

en WinNT.h.

Use la bandera del compilador, por ejemplo, bandera para GCC: -Wno-unused-variable

Puede usar __unusedpara decirle al compilador que la variable podría no usarse.

- (void)myMethod:(__unused NSObject *)theObject    
{
    // there will be no warning about `theObject`, because you wrote `__unused`

    __unused int theInt = 0;
    // there will be no warning, but you are still able to use `theInt` in the future
}

En C ++ 11, esta es la solución que estoy usando:

template<typename... Ts> inline void Unreferenced(Ts&&...) {}

int Foo(int bar) 
{
    Unreferenced(bar);
    return 0;
}

int Foo2(int bar1, int bar2) 
{
    Unreferenced(bar1, bar2);
    return 0;
}

Verificado como portátil (al menos en msvc, clang y gcc modernos) y que no produce código adicional cuando las optimizaciones están habilitadas. Sin optimización, la llamada de función adicional se realiza y las referencias a los parámetros se copian en la pila, pero no hay macros involucradas.

Si el código adicional es un problema, puede usar esta declaración en su lugar:

(decltype(Unreferenced(bar1, bar2)))0;

pero en ese punto, una macro proporciona una mejor legibilidad:

#define UNREFERENCED(...) { (decltype(Unreferenced(__VA_ARGS__)))0; }

Esto funciona bien pero requiere C ++ 11

template <typename ...Args>
void unused(Args&& ...args)
{
  (void)(sizeof...(args));
}

Encontré que la mayoría de las respuestas presentadas funcionan solo para la variable local no utilizada y causarán un error de compilación para la variable global estática no utilizada.

Otra macro necesaria para suprimir la advertencia de variable global estática no utilizada.

template <typename T>
const T* UNUSED_VARIABLE(const T& dummy) { 
    return &dummy;
}
#define UNUSED_GLOBAL_VARIABLE(x) namespace {\
    const auto dummy = UNUSED_VARIABLE(x);\
}

static int a = 0;
UNUSED_GLOBAL_VARIABLE(a);

int main ()
{
    int b = 3;
    UNUSED_VARIABLE(b);
    return 0;
}

Esto funciona porque no se informará ninguna advertencia para la variable global no estática en el espacio de nombres anónimo.

Sin embargo, se requiere C ++ 11

 g++  -Wall -O3  -std=c++11 test.cpp

Jajaja ¡No creo que haya otra pregunta sobre SO que revele todos los herejes corrompidos por el Caos mejor que este!

Con el debido respeto a C ++ 17, hay una directriz clara en las Pautas principales de C ++ . AFAIR, en 2009, esta opción estaba disponible tanto como hoy. Y si alguien dice que se considera un error en Doxygen, entonces hay un error en Doxygen

No veo tu problema con la advertencia. Documente en el encabezado de método / función que el compilador xy emitirá una advertencia (correcta) aquí, pero que estas variables son necesarias para la plataforma z.

La advertencia es correcta, no es necesario apagarla. No invalida el programa, pero debe documentarse que hay una razón.