Como melhor silenciar um aviso sobre variáveis ​​não utilizadas?

Eu tenho um aplicativo de plataforma cruzada e em algumas de minhas funções nem todos os valores passados ​​para as funções são utilizados. Por isso, recebo um aviso do GCC informando que existem variáveis ​​não utilizadas.

Qual seria a melhor maneira de codificar o aviso?

Um #ifdef em torno da função?

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

Isso é tão feio, mas parece da maneira que o compilador prefere.

Ou atribuo zero à variável no final da função? (que eu odeio porque está alterando algo no fluxo do programa para silenciar um aviso do compilador).

Existe uma maneira correta?

Você pode colocá-lo na (void)var;expressão " " (não faz nada) para que um compilador veja que ele é usado. Isso é portátil entre compiladores.

Por exemplo

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

Ou,

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

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

No GCC e no Clang, você pode usar a __attribute__((unused))diretiva de pré - processador para atingir seu objetivo.
Por exemplo:

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

C ++ 17 agora fornece o [[maybe_unused]]atributo

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

Bastante agradável e padrão.

Sua solução atual é a melhor - comente o nome do parâmetro se você não o usar. Isso se aplica a todos os compiladores, portanto você não precisa usar o pré-processador para fazê-lo especialmente no GCC.

Atualização C ++ 17

No C ++ 17, obtemos o atributo [[maybe_unused]], coberto em [dcl.attr.unused]

O token de atributo maybe_unused indica que um nome ou entidade possivelmente não é utilizado intencionalmente. Ele deve aparecer no máximo uma vez em cada lista de atributos e nenhuma cláusula de argumento-argumento deve estar presente. ...

Exemplo:

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

As implementações não devem avisar que b não está sendo usado, se NDEBUG está ou não definido. Exemplo final]

Para o seguinte exemplo:

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

Clang e gcc geram um diagnóstico usando -Wall -Wextra para bar e unused_bool ( Veja ao vivo ).

Ao adicionar [[maybe_unused]] silencia o diagnóstico:

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

veja ao vivo .

Antes do C ++ 17

No C ++ 11, uma forma alternativa da UNUSEDmacro pode ser formada usando uma expressão lambda ( via Ben Deane ) com uma captura da variável não utilizada:

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

A chamada imediata da expressão lambda deve ser otimizada, dado o seguinte exemplo:

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

podemos ver em godbolt que a chamada está otimizada:

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

Uma maneira ainda mais limpa é apenas comentar os nomes das variáveis:

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

Um colega de trabalho acabou de me apontar para esta bela macro aqui

Para facilitar, incluirei a macro abaixo.

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

gccnão sinaliza esses avisos por padrão. Esse aviso deve ter sido ativado explicitamente passando -Wunused-parameterpara o compilador ou implicitamente passando -Wall -Wextra(ou possivelmente alguma outra combinação de sinalizadores).

Os avisos de parâmetro não utilizados podem ser simplesmente suprimidos, passando -Wno-unused-parameterpara o compilador, mas observe que esse sinalizador de desativação deve vir após qualquer sinalizador de ativação possível para esse aviso na linha de comando do compilador, para que ele entre em vigor.

maneira sem macro e portátil de declarar um ou mais parâmetros como não utilizados:

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

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

O uso de diretivas de pré-processador é considerado ruim na maioria das vezes. Idealmente, você deseja evitá-los como a praga. Lembre-se de que é fácil fazer o compilador entender seu código, permitindo que outros programadores entendam seu código muito mais difícil. Algumas dezenas de casos como esse aqui e ali dificultam a leitura para você mais tarde ou para outras pessoas agora.

Uma maneira pode ser reunir seus parâmetros em algum tipo de classe de argumento. Você poderia usar apenas um subconjunto das variáveis ​​(equivalente a atribuir 0 realmente) ou ter diferentes especializações dessa classe de argumentos para cada plataforma. No entanto, isso pode não valer a pena, você precisa analisar se isso se encaixaria.

Se você conseguir ler modelos impossíveis, poderá encontrar dicas avançadas no livro "Excepcional C ++". Se as pessoas que leram o seu código pudessem incluir suas habilidades abrangendo as coisas loucas ensinadas nesse livro, você teria um código bonito que também pode ser facilmente lido. O compilador também estaria bem ciente do que você está fazendo (em vez de ocultar tudo com o pré-processamento)

Primeiro, o aviso é gerado pela definição de variável no arquivo de origem e não no arquivo de cabeçalho. O cabeçalho pode permanecer intocado e deve, pois você pode estar usando algo como doxygen para gerar a documentação da API.

Assumirei que você tenha uma implementação completamente diferente nos arquivos de origem. Nesses casos, você pode comentar o parâmetro incorreto ou apenas escrever o parâmetro.

Exemplo:

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

Isso pode parecer enigmático, então definiu uma macro como NÃO UTILIZADA. A maneira como o MFC fez isso é:

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

Assim você vê o aviso ainda nas compilações de depuração, pode ser útil.

Não é seguro comentar sempre os nomes dos parâmetros? Se não for, você pode fazer algo como

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

É um pouco menos feio.

Eu vi isso em vez da (void)param2maneira de silenciar o aviso:

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

Parece que isso foi adicionado no C ++ 11

Usando um UNREFERENCED_PARAMETER(p)poderia funcionar. Eu sei que ele está definido no WinNT.h para sistemas Windows e também pode ser facilmente definido para o gcc (se ainda não o tiver).

UNREFERENCED PARAMETER(p) é definido como

#define UNREFERENCED_PARAMETER(P)          (P)

no WinNT.h.

Use a bandeira do compilador, por exemplo, bandeira para o GCC: -Wno-unused-variable

Você pode usar __unusedpara informar ao compilador que a variável não pode ser usada.

- (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
}

No C ++ 11, esta é a solução que estou 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;
}

Verificado como portátil (pelo menos no msvc moderno, clang e gcc) e não produzindo código extra quando as otimizações estão ativadas. Sem otimização, a chamada de função extra é executada e as referências aos parâmetros são copiadas para a pilha, mas não há macros envolvidas.

Se o código extra for um problema, você poderá usar esta declaração:

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

mas, nesse ponto, uma macro fornece melhor legibilidade:

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

Isso funciona bem, mas requer C ++ 11

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

Descobri que a maioria das respostas apresentadas funciona apenas para variáveis ​​locais não utilizadas e causará erro de compilação para variável global estática não utilizada.

Outra macro necessária para suprimir o aviso de variável global estática não utilizada.

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;
}

Isso funciona porque nenhum aviso será relatado para variável global não estática no espaço para nome anônimo.

C ++ 11 é necessário

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

Ri muito! Eu não acho que exista outra pergunta sobre SO que revele todos os hereges corrompidos pelo Caos melhor que este!

Com todo o respeito ao C ++ 17, há uma diretriz clara nas Diretrizes Principais do C ++ . AFAIR, em 2009 essa opção estava disponível também hoje. E se alguém diz que é considerado um bug no Doxygen, existe um bug no Doxygen

Não vejo seu problema com o aviso. Documente no cabeçalho do método / função que o compilador xy emitirá um aviso (correto) aqui, mas que essas variáveis ​​são necessárias para a plataforma z.

O aviso está correto, não há necessidade de desligá-lo. Ele não invalida o programa - mas deve ser documentado, que existe um motivo.