Suprimir la advertencia variables sin utilizar en C ++ => error del compilador o error de código?

Question

Actualmente, estoy usando la siguiente plantilla de función para eliminar las advertencias variables utilizadas:

template<typename T>
void
unused(T const &) {
  /* Do nothing. */
}

Sin embargo, cuando la migración a cygwin de Linux, ahora estoy recibiendo errores de compilación en g ++ 3.4.4 (En Linux 3.4.6 soy, así que quizás es una corrección de errores?):

Write.cpp: In member function `void* Write::initReadWrite()':
Write.cpp:516: error: invalid initialization of reference of type 'const volatile bool&' from expression of type 'volatile bool'
../../src/common/Assert.h:27: error: in passing argument 1 of `void unused(const T&) [with T = volatile bool]'
make[1]: *** [ARCH.cygwin/release/Write.o] Error 1

El argumento para no utilizada es una variable miembro de declararse como:

  volatile bool readWriteActivated;

Es esto un error compilador o un error en mi código?

Este es el caso de prueba mínima:

template<typename T>
void unused(T const &) { }

int main() {
  volatile bool x = false;
  unused(!x); // type of "!x" is bool
}

Answer 1

Es un error del compilador y no hay arounds de trabajo conocidos:

http://gcc.gnu.org/bugzilla/show_bug.cgi ? id = 42655

Se fija en v4.4.

Answer 2

La forma más efectiva de lo que indica que en realidad no utilizar un parámetro no está dando un nombre:

int f(int a, float) {
     return a*2;
}

compilará todas partes con todas las advertencias activadas, sin advertencia sobre el flotador no utilizado. Incluso si el argumento no tiene un nombre en el prototipo (por ejemplo int f(int a, float f);), todavía no se quejará.

Answer 3

No estoy 100% seguro de que este es portátil, pero esto es el lenguaje que he utilizado por lo general para la supresión de advertencias acerca de las variables utilizadas. El contexto aquí es un manejador de señales que sólo se utiliza para atrapar SIGINT y SIGTERM, por lo que si la función se llama cada vez sé que es hora de que el programa termine.

volatile bool app_killed = false;
int signal_handler(int signum)
{
    (void)signum; // this suppresses the warnings
    app_killed = true;
}

Me tienden a rechazar estorbar encima de la lista de parámetros con __attribute__((unused)), ya que el truco-fundido al vacío funciona sin tener que recurrir a las macros de Visual C ++.

Answer 4

En GCC, se puede definir una macro de la siguiente manera:

#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 

Cualquier parámetros marcados con este macro suprimirá la emite CCG advertencia no utilizados (y cambia el nombre del parámetro con un prefijo de UNUSED_). Para Visual Studio, puede suprimir las advertencias con una directiva #pragma.

Answer 5

La respuesta propuesto por haavee (modificada por ur) es el que normalmente se utiliza:

int f(int a, float /*epsilon*/) {
     return a*2;
}

El verdadero problema ocurre cuando el argumento es a veces , pero no siempre se usa en el método, por ejemplo:.

int f(int a, float epsilon) {
#ifdef LOGGING_ENABLED
     LOG("f: a = %d, epsilon = %f\n", a, epsilon);
#endif
     return a*2;
}

Ahora, no puedo comentar el nombre del parámetro épsilon porque eso va a romper mi registro de acumulación (no quiero insertar otro #ifdef en la lista de argumentos, ya que hace que el código mucho más difícil de leer).

Así que creo que la mejor solución sería utilizar la sugerencia de Tom:

int f(int a, float epsilon) {
(void) epsilon;    // suppress compiler warning for possibly unused arg
#ifdef LOGGING_ENABLED
     LOG("f: a = %d, epsilon = %f\n", a, epsilon);
#endif
     return a*2;
}

Mi única preocupación sería que algunos compiladores pueden alertar sobre la "épsilon (void);" declaración, por ejemplo, "La declaración no tiene ningún efecto" advertencia o algo parecido - Creo que voy a tener que probar en todos los compiladores tengo tendencia a utilizar ...