Désactiver l'erreur d'avertissement unique

Existe-t-il un moyen de désactiver une seule ligne d'avertissement dans un fichier cpp avec Visual Studio?

Par exemple, si j'attrape une exception et que je ne la gère pas, j'obtiens l'erreur 4101 (variable locale non référencée). Existe-t-il un moyen d'ignorer cela uniquement dans cette fonction, mais sinon de le signaler dans l'unité de compilation? Pour le moment, je mets #pragma warning (disable : 4101)en haut du fichier, mais cela l'éteint évidemment pour l'ensemble de l'unité.

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

Si vous ne souhaitez supprimer un avertissement que sur une seule ligne de code, vous pouvez utiliser le suppress spécificateur d'avertissement :

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

Pour une seule ligne de code, cela fonctionne de la même manière que l'écriture de ce qui suit:

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

#pragma push / pop sont souvent une solution à ce genre de problèmes, mais dans ce cas, pourquoi ne supprimez-vous pas simplement la variable non référencée?

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

Utilisez #pragma warning ( push ), puis #pragma warning ( disable ), puis mettez votre code, puis utilisez #pragma warning ( pop )comme décrit ici :

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

Exemple:

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

Ce pragma est valide pour C ++ à partir de Visual Studio 2005.
https://msdn.microsoft.com/en-us/library/2c8f766e(v=vs.80).aspx

Le pragma n'est PAS valide pour C # via Visual Studio 2005 via Visual Studio 2015.
Erreur: «Désactivation ou restauration attendue».
(Je suppose qu'ils n'ont jamais réussi à mettre en œuvre suppress...)
https://msdn.microsoft.com/en-us/library/441722ys(v=vs.140).aspx

C # a besoin d'un format différent. Cela ressemblerait à ceci (mais ne fonctionnerait pas):

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

Au lieu de suppress, vous devez disableet enable:

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

C'est tellement moche, je pense qu'il est plus intelligent de simplement le remodeler:

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

Au lieu de le placer au-dessus du fichier (ou même d'un fichier d'en-tête), enveloppez simplement le code en question avec #pragma warning (push), #pragma warning (disable)et une correspondance #pragma warning (pop), comme indiqué ici .

Bien qu'il existe d'autres options, notamment #pramga warning (once).

On peut également utiliser UNREFERENCED_PARAMETERdéfini dans WinNT.H. La définition est juste:

#define UNREFERENCED_PARAMETER(P)          (P)

Et utilisez-le comme:

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

Pourquoi l'utiliseriez-vous, vous pourriez dire que vous pouvez simplement omettre le nom de la variable lui-même. Eh bien, il y a des cas (configuration de projet différente, versions Debug / Release) où la variable peut être utilisée. Dans une autre configuration, cette variable reste inutilisée (et donc l'avertissement).

Certaines analyses de code statique peuvent toujours donner un avertissement pour cette instruction non-absurde ( wParam;). Dans ce cas, vous pouvez utiliser DBG_UNREFERENCED_PARAMETERce qui est le même que UNREFERENCED_PARAMETERdans les versions de débogage et qui le fait P=Pdans la version de version.

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

Si vous souhaitez désactiver l' unreferenced local variableécriture dans un en-tête

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

et utilise

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

Dans certaines situations, vous devez avoir un paramètre nommé mais vous ne l'utilisez pas directement.
Par exemple, je l'ai rencontré sur VS2010, lorsque 'e' est utilisé uniquement dans une decltypeinstruction, le compilateur se plaint mais vous devez avoir la variable nomméee .

Toutes les non- #pragmasuggestions ci-dessus se résument toutes à l'ajout d'une seule déclaration:

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

comme @rampion l'a mentionné, si vous êtes dans clang gcc, les avertissements sont par nom, pas par numéro, et vous devrez faire:

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

cette information vient d' ici