Desactivar error de advertencia único

¿Hay alguna forma de deshabilitar una sola línea de advertencia en un archivo cpp con Visual Studio?

Por ejemplo, si detecto una excepción y no la manejo, obtengo el error 4101 (variable local sin referencia). ¿Hay alguna manera de ignorar esto solo en esa función, pero de lo contrario informarlo en la unidad de compilación? Por el momento, lo coloco #pragma warning (disable : 4101)en la parte superior del archivo, pero eso obviamente lo apaga para toda la unidad.

#pragma warning( push )
#pragma warning( disable : 4101)
// Your function
#pragma warning( pop ) 

Si solo desea suprimir una advertencia en una sola línea de código, puede usar el suppress especificador de advertencia :

#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 igual que escribir lo siguiente:

#pragma warning(push)
#pragma warning(disable: 4101)
// here goes your code where the warning occurs
#pragma warning(pop)

#pragma push / pop son a menudo una solución para este tipo de problemas, pero en este caso, ¿por qué no elimina la variable sin referencia?

try
{
    // ...
}
catch(const your_exception_type &) // type specified but no variable declared
{
    // ...
}

Use #pragma warning ( push ), luego #pragma warning ( disable ), luego ingrese su código, luego use #pragma warning ( pop )como se describe aquí :

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

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 # hasta Visual Studio 2005 hasta Visual Studio 2015.
Error: "Deshabilitación o restauración esperada".
(Supongo que nunca llegaron 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 funcionaría):

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

En lugar de suppress, tienes que disabley enable:

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

Eso es TAN feo, creo que es más inteligente simplemente rediseñarlo:

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

En vez de ponerlo en la parte superior del archivo (o incluso un archivo de cabecera), simplemente envolver el código en cuestión con #pragma warning (push), #pragma warning (disable)y una coincidencia #pragma warning (pop), como se muestra aquí .

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

También se puede usar UNREFERENCED_PARAMETERdefinido en WinNT.H. La definición es simplemente:

#define UNREFERENCED_PARAMETER(P)          (P)

Y utilícelo como:

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

Por qué lo usaría, podría argumentar que puede omitir el nombre de la variable en sí. Bueno, hay casos (configuración de proyecto diferente, compilaciones de depuración / lanzamiento) en los que la variable podría usarse realmente. En otra configuración, esa variable no se utiliza (y de ahí la advertencia).

Algunos análisis de código estático aún pueden dar una advertencia para esta declaración sin sentido ( wParam;). En ese caso, puede usar DBG_UNREFERENCED_PARAMETERlo mismo que UNREFERENCED_PARAMETERen las compilaciones de depuración y P=Pen la compilación de lanzamiento.

#define DBG_UNREFERENCED_PARAMETER(P)      (P) = (P)

Si desea deshabilitar la unreferenced local variableescritura en algún encabezado

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

y use

catch(const Except & excpt) {
    ignore(excpt); // No warning
    // ...  
} 

En ciertas situaciones, debe tener un parámetro con nombre, pero no lo usa directamente.
Por ejemplo, me lo encontré en VS2010, cuando 'e' se usa solo dentro de una decltypedeclaración, el compilador se queja pero debe tener la variable nombrada e.

Todas las no #pragmasugerencias anteriores se reducen a solo agregar una sola declaración:

bool f(int e)
{ 
   // code not using e
   return true;
   e; // use without doing anything
}

como mencionó @rampion, si está en clang gcc, las advertencias son por nombre, no por número, y deberá hacer lo siguiente:

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

esta información viene de aquí