c++ - para - manual de programacion android pdf

Deshabilitar error de advertencia único

Question

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

Por ejemplo, si capturo 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, puse #pragma warning (disable : 4101) en la parte superior del archivo, pero eso obviamente lo apaga para toda la unidad.

Answer 1

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: "Deshabilitar o restaurar esperado".
(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 funciona):

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

En lugar de suppress , debe disable y 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 re-estilo:

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

Answer 2

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

Todas las sugerencias anteriores que no son #pragma reducen a solo agregar una única declaración:

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

Answer 3

En lugar de ponerlo encima del archivo (o incluso un archivo de encabezado), simplemente ajuste el código en cuestión con #pragma warning (push) , #pragma warning (disable) y una #pragma warning (pop) coincidente #pragma warning (pop) , como se muestra here .

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

Answer 4

Si desea desactivar unreferenced local variable escritura de unreferenced local variable en algún encabezado

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

y use

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

Answer 5

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

#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)

Answer 6

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

#define UNREFERENCED_PARAMETER(P) (P)

Y úsalo como:

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

¿Por qué lo usarías, podrías argumentar que puedes omitir el nombre de la variable en sí mismo? Bueno, hay casos (configuración de proyecto diferente, compilaciones de Depuración / Versión) donde la variable realmente podría ser utilizada. En otra configuración, esa variable permanece sin usar (y de ahí la advertencia).

Algunos análisis de código estático aún pueden dar advertencia para esta declaración no absurda ( wParam; ). En ese caso, puede DBG_UNREFERENCED_PARAMETER que es igual a UNREFERENCED_PARAMETER en las UNREFERENCED_PARAMETER de depuración, y P=P en la versión de compilación.

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

Answer 7

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

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

Answer 8

#pragma push / pop suele ser 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
{
// ...
}

Answer 9

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