Pregunta Parámetro no utilizado en c ++ 11


En c ++ 03 y anteriores para deshabilitar la advertencia del compilador sobre el parámetro no utilizado usualmente uso dicho código:

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

Por ejemplo

int main(int argc, char *argv[])
{
    UNUSED(argc);
    UNUSED(argv);

    return 0;
}

Pero las macros no son las mejores prácticas para c ++, entonces. ¿Alguna solución mejor aparece con el estándar c ++ 11? Quiero decir, ¿puedo deshacerme de las macros?

¡Gracias por todo!


73
2018-04-02 12:18


origen


Respuestas:


He usado una función con un cuerpo vacío para ese propósito:

template <typename T>
void ignore(T &&)
{ }

void f(int a, int b)
{
  ignore(a);
  ignore(b);
  return;
}

Espero que cualquier compilador serio optimice la función llamada y silencia las advertencias para mí.


35
2018-04-02 12:55



Puedes omitir los nombres de los parámetros:

int main(int, char *[])
{

    return 0;
}

Y en el caso de main, incluso puedes omitir los parámetros por completo:

int main()
{
    // no return implies return 0;
}

Consulte "§ 3.6 Inicio y terminación" en el estándar C ++ 11.


177
2018-04-02 12:19



Ahí está el <tuple> en C ++ 11, que incluye el listo para usar std::ignore objeto, eso nos permite escribir (muy probablemente sin imponer gastos generales de tiempo de ejecución):

void f(int x)
{
    std::ignore = x;
}

33
2018-05-27 07:59



Nada equivalente, no.

Entonces estás atrapado con las mismas viejas opciones. ¿Estás feliz de omitir por completo los nombres en la lista de parámetros?

int main(int, char**)

En el caso específico de main, por supuesto, simplemente podría omitir los parámetros:

int main()

También existen los típicos trucos específicos de implementación, como los GCC. __attribute__((unused)).


30
2018-04-02 12:20



Para "desactivar" esta advertencia, lo mejor es evitar escribir el argumento, solo escriba el tipo.

void function( int, int )
{
}

o si lo prefiere, coméntelo:

void function( int /*a*/, int /*b*/ )
{
}

Puede mezclar argumentos con nombre y sin nombre:

void function( int a, int /*b*/ )
{
}

Con C ++ 17 tiene el especificador de atributos [[maybe_unused]], como:

void function( [[maybe_unused]] int a, [[maybe_unused]] int b )
{
}

22
2018-04-03 11:41



Las macros pueden no ser ideales, pero hacen un buen trabajo para este propósito en particular. Yo diría que se adhieren a usar la macro.


13
2018-04-02 12:24



¿Qué tienes en contra de la forma antigua y estándar?

void f(int a, int b)
{
  (void)a;
  (void)b;
  return;
}

13
2018-04-02 18:11



No hay nada nuevo disponible.

Lo que funciona mejor para mí es comentar el nombre del parámetro en la implementación. De esta forma, se deshace de la advertencia, pero aún retiene alguna noción de cuál es el parámetro (ya que el nombre está disponible).

Su macro (y cualquier otro enfoque de conversión al vacío) tiene la desventaja de que puede usar el parámetro después de usar la macro. Esto puede hacer que el código sea más difícil de mantener.


12
2018-04-02 12:29



El encabezado de Boost <boost/core/ignore_unused.hpp> (Boost> = 1.56) define, para este propósito, la plantilla de función boost::ignore_unused().

int fun(int foo, int bar)
{
  boost::ignore_unused(bar);
#ifdef ENABLE_DEBUG_OUTPUT
  if (foo < bar)
    std::cerr << "warning! foo < bar";
#endif

  return foo + 2;
}

PS C ++ 17 parece estar consiguiendo un [[maybe_unused]] atributo para proporcionar una forma estándar de declarar una variable no utilizada.


9
2018-06-19 15:47