Actualmente, estoy usando la siguiente plantilla de función para suprimir sin usar la variable advertencias:

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

Sin embargo, al trasladar a cygwin desde Linux, ahora estoy tomando errores del compilador g++ 3.4.4 (En linux estoy 3.4.6, así que tal vez esta es una corrección de error?):

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 no utilizados es un miembro de la variable declarada como:

  volatile bool readWriteActivated;

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

Aquí es el mínimo de caso de prueba:

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

int main() {
  volatile bool x = false;
  unused(!x); //type of "!x" is bool
}
  • Yo no puedo reproducir el problema. Puedes publicar el código que se reproduce el problema.
  • WilliamKF – ¿por Qué has aceptado una respuesta que claramente no se soluciona el problema?
InformationsquelleAutor WilliamKF | 2009-12-15

5 Comentarios

  1. 28

    La verdadera forma de indicar que en realidad no utilizar un parámetro no es darle un nombre:

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

    recopilará todas partes con todas las advertencias encendido, sin advertencia sobre la parte no utilizada de flotación. Incluso si el argumento tiene un nombre en el prototipo (por ejemplo,int f(int a, float f);), aún así no se quejan.

    • +1, esta es la forma correcta de hacerlo.
    • Sí, y yo uso normalmente algo como int f(int count, float /*épsilon*/ ) en orden a nombre de la parte no utilizada del parámetro y su significado.
    • De hecho, ur, que los buenos modales, me olvidé de eso, pero tienes toda la razón.
    • +1. Junto con ur sugerencia, la más limpia y expresiva manera de hacerlo.
    • Esto no es lo que la pregunta está pidiendo. Omitiendo el nombre de la variable para la función arg funciona muy bien, pero aquí se declara la variable dentro de la función, y por lo tanto no puede ser omitido. Además en este caso, el nombre de la variable es necesario ya que se utiliza en los #ifdef de los casos y no es para el otro de modo que no se genera la advertencia.
    • Si usted no lo utiliza, no se declara. Aún más simple!
    • +1, muy útil.
    • El problema con no nombrar a los parámetros es que usted puede ser que necesite para inspeccionar más adelante. Cuando intenta ver sus valores en el depurador, te deseo que les había dado los nombres.
    • Si están sin usar, no hay mucho para inspeccionar en el depurador.

  2. 9

    No estoy 100% seguro de que este es portátil, pero este es el lenguaje que he utilizado generalmente para la supresión de las advertencias acerca de las variables sin usar. El contexto aquí es un manejador de señal que sólo se utiliza para la captura de SIGINT y SIGTERM, así que si la función es siempre el que llama, yo sé que es tiempo para que el programa se cierre.

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

    Tiendo a disgusto recargar la lista de parámetros con __attribute__((unused)), desde la fundición a vacío truco funciona sin tener que recurrir a las macros de Visual C++.

    • Sí, es legal C++ y portátil.
    • Si queremos hacer de este enfoque es compatible con el código existente que utiliza no utilizados(), definir una macro: #define unused(x) ((void)x)
    • Esto no funcionará si la variable es una referencia a un tipo incompleta. E. g., struct a; void f(a &a_) { (void)a_; } dará un error de compilación.
    • si usted no necesita usar a signum, ¿qué pasa si usted acaba de hacer es un parámetro sin nombre… como este: int signal_handler(int) Que encaja en el mismo prototipo, y posiblemente incluso ahorrar algo de memoria
  3. 2

    En GCC, usted 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) /*@[email protected]*/x
    #else
    # define UNUSED(x) x
    #endif 

    Cualquiera de los parámetros marcados con esta macro se suprime la parte no utilizada de advertencia GCC emite (y cambia el nombre del parámetro con un prefijo de UNUSED_). Para Visual Studio, puede suprimir advertencias con un #pragma directiva.

    • Sí, pero esto es dependiente del compilador. La pregunta da la forma más común de hacer esto en un no-dependiente del compilador de la moda, sin embargo, como se muestra, es el ejercicio de un error en el compilador.
    • +1 este es el más portátil de respuesta. también, gcc apoya #pragma unused – consulte también la documentación del _Pragma directiva.
  4. 1

    La respuesta propuesta por haavee (modificada por la ur) es la que yo normalmente uso:

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

    El verdadero problema ocurre cuando el argumento es a veces pero no siempre se utilizan 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, yo no puedo comentar el nombre del parámetro épsilon, ya que se rompen mi registro de construir (no quiero insertar otro #ifdef en la lista de argumentos debido a que hace que el código sea mucho más difícil de leer).

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

    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 advertir sobre el «(void) epsilon;» declaración», por ejemplo, la instrucción «no tiene ningún efecto» advertencia o algo – creo que voy a tener que probar en todos los compiladores que tengo tendencia a usar…

Dejar respuesta

Please enter your comment!
Please enter your name here