Hay una manera de desactivar solo una advertencia de línea en un archivo cpp con visual studio?

Por ejemplo, si cojo una excepción y no la manipule, tengo un error 4101 (sin referencia variable local). Es allí una manera de ignorar esta justo en esa función, pero por lo demás informes en la unidad de compilación? Por el momento, me puse #pragma warning (disable : 4101) en la parte superior del archivo, pero que, evidentemente, la apaga para toda la unidad.

  • si usted menciona sólo el tipo y no el nombre de la excepción, no habrá ninguna advertencia. E. g. catch (const std::exception& /* unnamed */) {.... }. No responder a su pregunta, pero podría resolver su problema.
InformationsquelleAutor Cookie | 2011-08-23

10 Comentarios

  1. 160
    #pragma warning( push )
    #pragma warning( disable : 4101)
    //Your function
    #pragma warning( pop ) 
    • Supongo que esto funciona para incluye así?
    • sí, funciona para cualquier pieza de código que pasar por el compilador.
    • Para una más reciente, concisa respuesta, véase Daniel Seither la respuesta, a continuación.
    • clang no parecen apoyar esta pragma, pero usted puede conseguir el mismo efecto con #pragma clang diagnostic push, #pragma clang diagnostic ignored "-Wunused-variable", y #pragma clang diagnostic pop. Consulte «Controlar Diagnositics a Través de Pragmas» en el Clang Manual del Usuario
    • Desde que tengo uso de esta función con poca frecuencia, cuando lo hago, por lo general el viento en esta página para recordarme a mí mismo de la sintaxis. Acabo de poner alrededor de una llamada a un obsoleto función que puede que nunca se actualiza, por lo que la advertencia no me molestan en el compilador de listados, que voy a escanear religiosamente.
    • Para Visual Studio, el argumento de línea de comandos es /wd4101. Nota que no es la normal : entre el indicador y el número, y no se puede hacer una lista separada por comas de los números. Para otros compiladores que que se /nowarn:4101 lugar.

  2. 73

    Si sólo desea suprimir una advertencia en una sola línea de código, se puede utilizar el suppress advertencia especificador de:

    #pragma warning(suppress: 4101)
    //here goes your single line of code where the warning occurs

    Para una sola línea de código, esto funciona de la misma como la redacción de los siguientes:

    #pragma warning(push)
    #pragma warning(disable: 4101)
    //here goes your code where the warning occurs
    #pragma warning(pop)
    • Muy útil! Por desgracia, no trabajo para una sola línea que incluye un encabezado que genera la advertencia.
    • El suppress especificador opera en una sola, pre-procesado línea de código. Si la línea siguiente #pragma warning(suppress: ...) es un #include directiva (que se expande el archivo referenciado por el parámetro en la actual unidad de compilación), el efecto se aplica a la primera línea de ese archivo solamente. Esto debería ser obvio, ya que las advertencias son generados por el compilador. El compilador opera en el pre-procesado de código.
    • En ese caso le pido una post-procesado línea de código. pre-procesado significa que no ha sido traducido por el preprocesador todavía.
  3. 27

    #pragma push/pop son a menudo una solución para este tipo de problemas, pero en este caso ¿por qué no acaba de quitar el desreferenciada variable?

    try
    {
        //...
    }
    catch(const your_exception_type &) //type specified but no variable declared
    {
        //...
    }
    • Este no es un responderle a la pregunta. Concedido, esto podría resolver OP problema, pero no va a ayudar a los futuros lectores con una simular pregunta: «¿cómo puedo desactivar una advertencia específica para una parte específica de mi código?»
    • tres personas que ya respondió a la «oficial duda» de que otras personas pueden buscar, en lugar de eso traté de leer entre líneas y a resolver su problema real (llegar un minuto después de tu comentario :P).
    • como futuro lector doy fe de que esta respuesta, de hecho, me ayudó.
    • como un pasado escritor, me alegro de que eso ayudó. =)
  4. 9

    Uso #pragma warning ( push ), entonces #pragma warning ( disable ), a continuación, poner el código, a continuación, utilizar #pragma warning ( pop ) como se describe aquí:

    #pragma warning( push )
    #pragma warning( disable : WarningCode)
    //code with warning
    #pragma warning( pop ) 
  5. 4

    Vez de ponerlo en la parte superior del archivo (o incluso un archivo de encabezado), sólo ajustar el código en cuestión con #pragma warning (push), #pragma warning (disable) y un juego #pragma warning (pop), como se muestra aquí.

    Aunque hay algunas otras opciones, incluyendo #pramga warning (once).

  6. 4

    También se puede utilizar UNREFERENCED_PARAMETER definido en WinNT.H. La definición es simple:

    #define UNREFERENCED_PARAMETER(P)          (P)

    Y utilizarlo como:

    void OnMessage(WPARAM wParam, LPARAM lParam)
    {
        UNREFERENCED_PARAMETER(wParam);
        UNREFERENCED_PARAMETER(lParam);
    }

    ¿Por qué se utiliza, se puede argumentar que sólo se puede omitir el nombre de la variable en sí. Bueno, hay casos (proyecto diferente configuración, Depuración de las versiones de Lanzamiento) donde la variable puede ser utilizada. En otra configuración de variable que se levanta sin usar (y de ahí la advertencia).

    Algunos de análisis de código estático todavía puede darle advertencia de esta no-sentido de la declaración (wParam;). En ese caso, usted mayuse DBG_UNREFERENCED_PARAMETER que es la misma que UNREFERENCED_PARAMETER en las versiones de depuración, y no P=P en la versión de lanzamiento.

    #define DBG_UNREFERENCED_PARAMETER(P)      (P) = (P)
  7. 4

    Ejemplo:

    #pragma warning(suppress:0000)  //(suppress one error in the next line)

    Este pragma es válido para C++ a partir de Visual Studio 2005.

    https://msdn.microsoft.com/en-us/library/2c8f766e(v=vs 80).aspx

    El pragma NO es válido para C# a través de Visual Studio 2005 a través de Visual Studio 2015.

    Error: «Espera o deshabilitar restaurar».

    (Supongo que nunca se llegó a implementar suppress …)

    https://msdn.microsoft.com/en-us/library/441722ys(v=vs 140).aspx

    C# necesita un formato diferente. Se vería así (pero no de trabajo):

    #pragma warning suppress 0642  //(suppress one error in the next line)

    Lugar de suppress, usted tiene que disable y enable:

    if (condition)
    #pragma warning disable 0642
        ;  //Empty statement HERE provokes Warning: "Possible mistaken empty statement" (CS0642)
    #pragma warning restore 0642
    else

    Que es TAN feo, creo que es más inteligente que acaba de volver a su estilo:

    if (condition)
    {
        //Do nothing (because blah blah blah).
    }
    else
  8. 2

    En ciertas situaciones debe tener un parámetro con nombre pero no lo uso directamente.

    Por ejemplo, me encontré en VS2010, cuando ‘e’ se utiliza sólo en el interior de un decltype declaración, el compilador se queja, pero usted debe tener el nombre de la varible e.

    Todo lo anterior no#pragma sugerencias de todos se reducen a sólo añadir una sola instrucción:

    bool f(int e)
    { 
       //code not using e
       return true;
       e; //use without doing anything
    }
    • ahora (en el MS VS2015 compilador) esto provoca advertencia c4702 código inalcanzable
  9. 2

    como @rampion mencionado, si usted está en clang gcc, los avisos son por nombre, no por su número, y usted necesitará hacer:

    #pragma clang diagnostic push
    #pragma clang diagnostic ignored "-Wunused-variable"
    //..your code..
    #pragma clang diagnostic pop

    esta información proviene de aquí

  10. 1

    Si quieres deshabilitar unreferenced local variable escribir en algunos encabezado

    template<class T>
    void ignore (const T & ) {}

    y uso

    catch(const Except & excpt) {
        ignore(excpt); //No warning
        //...  
    } 
    • Una llamada a una función, sólo para suprimir la advertencia? ¿Por qué no hacer esto en su lugar : (void)unusedVar;?
    • Creo que (void)unusedVar;?no es el Estándar de C++ compatible.
    • Quien dijo? Cualquier referencia?
    • No hay ninguna referencia necesaria. El estándar de C++. No es un código válido. ¿Qué es esto? Expresión? Llamada a la función? typedef? la declaración de la clase?
    • Es una expresión cuyo valor es nada. En C++, usted puede incluso hacer static_cast<void>(unusedVar).
    • Herb Sutter explicación: herbsutter.com/2009/10/18/mailbag-shutting-up-compiler-warnings
    • §5.2.9/4 dice, Any expression can be explicitly converted to type “cv void.” The expression value is discarded según la cual se puede escribir static_cast<void>(unusedVar) y static_cast<const void>(unusedVar) y static_cast<volatile void>(unusedVar). Todas las formas son válidas. Espero que te aclare tus dudas.

Dejar respuesta

Please enter your comment!
Please enter your name here