Disabilita errore di avviso singolo

C'è un modo per disabilitare solo una singola riga di avviso in un file cpp con Visual Studio?

Ad esempio, se rilevo un'eccezione e non la gestisco, ottengo l'errore 4101 (variabile locale non referenziata). C'è un modo per ignorarlo solo in quella funzione, ma altrimenti segnalarlo nell'unità di compilazione? Al momento, lo metto #pragma warning (disable : 4101)in cima al file, ma questo ovviamente lo spegne solo per l'intera unità.

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

Se desideri sopprimere un avviso in una singola riga di codice, puoi utilizzare l' suppress identificatore di avviso :

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

Per una singola riga di codice, funziona come scrivere quanto segue:

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

#pragma push / pop sono spesso una soluzione per questo tipo di problemi, ma in questo caso perché non rimuovi semplicemente la variabile non referenziata?

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

Usa #pragma warning ( push ), quindi #pragma warning ( disable ), quindi inserisci il tuo codice, quindi usa #pragma warning ( pop )come descritto qui :

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

Esempio:

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

Questo pragma è valido per C ++ a partire da Visual Studio 2005.
https://msdn.microsoft.com/en-us/library/2c8f766e(v=vs.80).aspx

Il pragma NON è valido per C # tramite Visual Studio 2005 tramite Visual Studio 2015.
Errore: "Disattivazione o ripristino previsti".
(Immagino che non siano mai riusciti a implementare suppress...)
https://msdn.microsoft.com/en-us/library/441722ys(v=vs.140).aspx

C # richiede un formato diverso. Sarebbe simile a questo (ma non funzionerebbe):

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

Invece di suppress, devi disablee enable:

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

È COSÌ brutto, penso che sia più intelligente ridisegnarlo:

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

Invece di mettere in cima al file (o anche un file di intestazione), basta inserire il codice in questione con #pragma warning (push), #pragma warning (disable)e un abbinamento #pragma warning (pop), come mostrato qui .

Sebbene ci siano altre opzioni, tra cui #pramga warning (once).

Si può anche usare UNREFERENCED_PARAMETERdefinito in WinNT.H. La definizione è solo:

#define UNREFERENCED_PARAMETER(P)          (P)

E usalo come:

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

Perché dovresti usarlo, potresti obiettare che puoi semplicemente omettere il nome della variabile stessa. Bene, ci sono casi (configurazione di progetto diversa, build di debug / rilascio) in cui la variabile potrebbe essere effettivamente utilizzata. In un'altra configurazione quella variabile è inutilizzata (e quindi l'avvertimento).

Alcune analisi statiche del codice possono ancora fornire un avviso per questa dichiarazione priva di senso ( wParam;). In tal caso, è possibile utilizzare la DBG_UNREFERENCED_PARAMETERstessa procedura delle UNREFERENCED_PARAMETERbuild di debug e P=Pdella build di rilascio.

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

Se vuoi disabilitare unreferenced local variablescrivi in ​​qualche header

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

e utilizzare

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

In certe situazioni devi avere un parametro denominato ma non lo usi direttamente.
Ad esempio, mi sono imbattuto in VS2010, quando 'e' è usato solo all'interno di decltypeun'istruzione, il compilatore si lamenta ma devi avere la variabile nominata e.

Tutti i suddetti non #pragmasuggerimenti si riducono alla semplice aggiunta di una singola affermazione:

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

come menzionato da @rampion, se sei in clang gcc, gli avvisi sono per nome, non per numero, e dovrai fare:

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

questa informazione proviene da qui