Come posso mettere a tacere un avviso sulle variabili non utilizzate?

Ho un'applicazione multipiattaforma e in alcune delle mie funzioni non vengono utilizzati tutti i valori passati alle funzioni. Quindi ricevo un avviso da GCC che mi dice che ci sono variabili non utilizzate.

Quale sarebbe il modo migliore per codificare l'avviso?

Un #ifdef attorno alla funzione?

#ifdef _MSC_VER
void ProcessOps::sendToExternalApp(QString sAppName, QString sImagePath, qreal qrLeft, qreal qrTop, qreal qrWidth, qreal qrHeight)
#else
void ProcessOps::sendToExternalApp(QString sAppName, QString sImagePath, qreal /*qrLeft*/, qreal /*qrTop*/, qreal /*qrWidth*/, qreal /*qrHeight*/)
#endif
{

Questo è così brutto ma sembra il modo in cui il compilatore preferirebbe.

O assegnare zero alla variabile alla fine della funzione? (che odio perché sta alterando qualcosa nel flusso del programma per mettere a tacere un avviso del compilatore).

C'è un modo corretto?

Puoi inserirlo (void)var;nell'espressione " " (non fa nulla) in modo che un compilatore lo veda utilizzato. Questo è portatile tra i compilatori.

Per esempio

void foo(int param1, int param2)
{
    (void)param2;
    bar(param1);
}

O,

#define UNUSED(expr) do { (void)(expr); } while (0)
...

void foo(int param1, int param2)
{
    UNUSED(param2);
    bar(param1);
}

In GCC e Clang puoi usare la __attribute__((unused))direttiva preprocessore per raggiungere il tuo obiettivo.
Per esempio:

int foo (__attribute__((unused)) int bar) {
   return 0;
}

C ++ 17 ora fornisce l' [[maybe_unused]]attributo.

http://en.cppreference.com/w/cpp/language/attributes

Abbastanza carino e standard.

La soluzione attuale è la migliore: commenta il nome del parametro se non la usi. Questo vale per tutti i compilatori, quindi non è necessario utilizzare il pre-processore per farlo appositamente per GCC.

Aggiornamento C ++ 17

In C ++ 17 otteniamo l'attributo [[maybe_unused]] che è coperto in [dcl.attr.unused]

Il token di attributo maybe_unused indica che un nome o un'entità è eventualmente intenzionalmente inutilizzato. Dovrà apparire al massimo una volta in ogni elenco di attributi e non dovrà essere presente alcuna clausola di argomento di attributo. ...

Esempio:

 [[maybe_unused]] void f([[maybe_unused]] bool thing1,
                        [[maybe_unused]] bool thing2) {
  [[maybe_unused]] bool b = thing1 && thing2;
    assert(b);
 }

Le implementazioni non devono avvisare che b non è utilizzato, indipendentemente dal fatto che sia definito o meno NDEBUG. —Esempio]

Per il seguente esempio:

int foo ( int bar) {
    bool unused_bool ;
    return 0;
}

Sia clang che gcc generano una diagnostica usando -Wall -Wextra sia per la barra che per unused_bool ( Guardalo dal vivo ).

Mentre aggiungi [[maybe_unused]] silenzia la diagnostica:

int foo ([[maybe_unused]] int bar) {
    [[maybe_unused]] bool unused_bool ;
    return 0;
}

vederlo dal vivo .

Prima di C ++ 17

In C ++ 11 una forma alternativa della UNUSEDmacro potrebbe essere formata usando un'espressione lambda ( via Ben Deane ) con una cattura della variabile non utilizzata:

#define UNUSED(x) [&x]{}()

L'invocazione immediata dell'espressione lambda dovrebbe essere ottimizzata, dato il seguente esempio:

int foo (int bar) {
    UNUSED(bar) ;
    return 0;
}

possiamo vedere in godbolt che la chiamata è ottimizzata via:

foo(int):
xorl    %eax, %eax
ret

Un modo ancora più pulito è semplicemente commentare i nomi delle variabili:

int main(int /* argc */, char const** /* argv */) {
  return 0;
}

Un collega mi ha appena indicato questa bella macro qui

Per semplicità includerò la macro qui sotto.

#ifdef UNUSED
#elif defined(__GNUC__) 
# define UNUSED(x) UNUSED_ ## x __attribute__((unused)) 
#elif defined(__LCLINT__) 
# define UNUSED(x) /*@unused@*/ x 
#else 
# define UNUSED(x) x 
#endif

void dcc_mon_siginfo_handler(int UNUSED(whatsig))

gccnon contrassegna questi avvisi per impostazione predefinita. Questo avviso deve essere stato attivato esplicitamente passando -Wunused-parameteral compilatore o implicitamente passando -Wall -Wextra(o eventualmente un'altra combinazione di flag).

Le avvertenze sui parametri non utilizzate possono essere semplicemente eliminate passando -Wno-unused-parameteral compilatore, ma si noti che questo flag di disabilitazione deve venire dopo eventuali flag di abilitazione per questo avviso nella riga di comando del compilatore, in modo che possa avere effetto.

modo macro-portatile e portatile per dichiarare uno o più parametri come inutilizzati:

template <typename... Args> inline void unused(Args&&...) {}

int main(int argc, char* argv[])
{
    unused(argc, argv);
    return 0;
}

L'uso delle direttive del preprocessore è considerato malvagio il più delle volte. Idealmente, vuoi evitarli come il parassita. Ricorda che far capire al compilatore il tuo codice è facile, permettere ad altri programmatori di capire il tuo codice è molto più difficile. Qualche decina di casi come questo qua e là rende molto difficile la lettura da soli in seguito o per gli altri in questo momento.

Un modo potrebbe essere quello di riunire i parametri in una sorta di classe di argomenti. È quindi possibile utilizzare solo un sottoinsieme delle variabili (equivalente alla propria assegnazione 0) o avere diverse specializzazioni di tale classe di argomenti per ciascuna piattaforma. Questo potrebbe tuttavia non valerne la pena, è necessario analizzare se si adatterebbe.

Se riesci a leggere modelli impossibili, potresti trovare suggerimenti avanzati nel libro "Eccezionale C ++". Se le persone che leggono il tuo codice potrebbero ottenere il loro skillset per comprendere le cose folli insegnate in quel libro, allora avresti un bellissimo codice che può anche essere facilmente letto. Il compilatore sarebbe anche ben consapevole di ciò che stai facendo (invece di nascondere tutto con la preelaborazione)

Innanzitutto l'avviso viene generato dalla definizione della variabile nel file di origine e non nel file di intestazione. L'intestazione può rimanere incontaminata e dovrebbe, poiché potresti usare qualcosa come doxygen per generare la documentazione API.

Presumo che tu abbia un'implementazione completamente diversa nei file sorgente. In questi casi puoi commentare il parametro offensivo o semplicemente scrivere il parametro.

Esempio:

func(int a, int b)
{
    b;
    foo(a);
}

Questo potrebbe sembrare criptico, così definito una macro come UNUSED. Il modo in cui lo ha fatto MFC è:

#ifdef _DEBUG
#define UNUSED(x)
#else
#define UNUSED(x) x
#endif

In questo modo vedi l'avviso ancora presente nelle build di debug, potrebbe essere utile.

Non è sicuro commentare sempre i nomi dei parametri? Altrimenti puoi fare qualcosa del genere

#ifdef _MSC_VER
# define P_(n) n
#else
# define P_(n)
#endif

void ProcessOps::sendToExternalApp(
    QString sAppName, QString sImagePath,
    qreal P_(qrLeft), qreal P_(qrTop), qreal P_(qrWidth), qreal P_(qrHeight))

È un po ' meno brutto.

Ho visto questo invece del (void)param2modo di mettere a tacere l'avvertimento:

void foo(int param1, int param2)
{
    std::ignore = param2;
    bar(param1);
}

Sembra che questo sia stato aggiunto in C ++ 11

L'uso di UNREFERENCED_PARAMETER(p)potrebbe funzionare. So che è definito in WinNT.h per sistemi Windows e può essere facilmente definito anche per gcc (se non lo possiede già).

UNREFERENCED PARAMETER(p) è definito come

#define UNREFERENCED_PARAMETER(P)          (P)

in WinNT.h.

Usa il flag del compilatore, ad esempio flag per GCC: -Wno-unused-variable

È possibile utilizzare __unusedper indicare al compilatore che la variabile potrebbe non essere utilizzata.

- (void)myMethod:(__unused NSObject *)theObject    
{
    // there will be no warning about `theObject`, because you wrote `__unused`

    __unused int theInt = 0;
    // there will be no warning, but you are still able to use `theInt` in the future
}

In C ++ 11, questa è la soluzione che sto usando:

template<typename... Ts> inline void Unreferenced(Ts&&...) {}

int Foo(int bar) 
{
    Unreferenced(bar);
    return 0;
}

int Foo2(int bar1, int bar2) 
{
    Unreferenced(bar1, bar2);
    return 0;
}

Verificato di essere portatile (almeno su moderni msvc, clang e gcc) e non produrre codice extra quando le ottimizzazioni sono abilitate. Senza ottimizzazione, viene eseguita la chiamata di funzione aggiuntiva e i riferimenti ai parametri vengono copiati nello stack, ma non sono coinvolte macro.

Se il codice aggiuntivo è un problema, puoi invece utilizzare questa dichiarazione:

(decltype(Unreferenced(bar1, bar2)))0;

ma a quel punto, una macro offre una migliore leggibilità:

#define UNREFERENCED(...) { (decltype(Unreferenced(__VA_ARGS__)))0; }

Funziona bene ma richiede C ++ 11

template <typename ...Args>
void unused(Args&& ...args)
{
  (void)(sizeof...(args));
}

Ho trovato che la maggior parte delle risposte presentate funziona solo per la variabile locale inutilizzata e causerà un errore di compilazione per la variabile globale statica inutilizzata.

Un'altra macro doveva sopprimere l'avvertimento della variabile globale statica inutilizzata.

template <typename T>
const T* UNUSED_VARIABLE(const T& dummy) { 
    return &dummy;
}
#define UNUSED_GLOBAL_VARIABLE(x) namespace {\
    const auto dummy = UNUSED_VARIABLE(x);\
}

static int a = 0;
UNUSED_GLOBAL_VARIABLE(a);

int main ()
{
    int b = 3;
    UNUSED_VARIABLE(b);
    return 0;
}

Ciò funziona perché non verrà segnalato alcun avviso per la variabile globale non statica nello spazio dei nomi anonimo.

C ++ 11 è richiesto però

 g++  -Wall -O3  -std=c++11 test.cpp

Lol! Non credo che ci sia un'altra domanda su SO che rivela meglio tutti gli eretici corrotti dal Caos!

Con tutto il rispetto per C ++ 17 c'è una chiara linea guida nelle Linee guida di base C ++ . AFAIR, nel 2009 questa opzione era disponibile anche oggi. E se qualcuno dice che è considerato un bug in Doxygen, allora c'è un bug in Doxygen

Non vedo il tuo problema con l'avvertimento. Documentalo nell'intestazione metodo / funzione che il compilatore xy emetterà un avviso (corretto) qui, ma che queste variabili sono necessarie per la piattaforma z.

L'avviso è corretto, non è necessario disattivarlo. Non invalida il programma, ma dovrebbe essere documentato, che esiste un motivo.