Por que alguém deveria querer desativar os avisos do compilador?

Esta resposta e os comentários adicionados a ela mostram uma maneira de desativar vários avisos do compilador usando #pragmadiretivas.

Por que alguém iria querer fazer isso? Geralmente, os avisos existem por um motivo, e sempre achei que eles são bons motivos. Existe algum "caso válido" em que os avisos devem ser desativados? No momento, não consigo pensar em nada, mas talvez seja apenas eu.

Eu só tive uma situação em que desativei um aviso. Eu considero erros de aviso para que normalmente não seja liberado com avisos. No entanto, durante o desenvolvimento de uma API em clientes, enfrentei o problema de que um método que era necessário em uma fase de migração por um aplicativo e que nenhum outro deveria usar deveria ser incluído na biblioteca.

A melhor maneira de encontrar para dizer a todos os usuários da API que eles não deveriam chamar esse método era marcá-lo como obsoleto. Isso, no entanto, significava que o único caso de uso válido foi marcado como um aviso de compilação.

Eric Lippert escreveu alguns posts sobre avisos, onde você encontrará informações sobre como a equipe do compilador pensa sobre os avisos.

Campos internos de tipos internos

As diretivas não utilizadas não são marcadas com avisos

Aqui estão alguns avisos em que a documentação fornece razões pelas quais você pode querer desativá-los:

• http://msdn.microsoft.com/pt-BR/library/4bw5ewxy(v=VS.80).aspx
• http://msdn.microsoft.com/pt-BR/library/sa4zat99(v=VS.80).aspx
• http://msdn.microsoft.com/pt-BR/library/9x19t380(v=VS.80).aspx

Outros exemplos incluem avisos sobre o uso de métodos depreciados, se você souber que ainda deseja usar o método antigo ou ter membros particulares que nunca são lidos localmente, mas com reflexão.

Na minha experiência, o C # tem menos necessidade de desabilitar avisos do que outros idiomas, como o C ++. Isso ocorre principalmente porque, como Eric Lippert diz em seu blog , eles "tentam reservar avisos apenas para aquelas situações em que podemos dizer com quase certeza que o código está quebrado, enganoso ou inútil".

Um exemplo em C do qual encontro variantes regularmente:

int doSomething(int argument1)
{
#ifdef HARDWARE_TYPE_A
    performAction(argument1);
#else
    displayNotSupportedMessage();
#endif
}

O argumento é relevante apenas em algumas plataformas, mas naquelas em que não é relevante, meu compilador reclamará e, como eu tenho avisos convertidos em erros, isso impedirá a criação.

A conversão de avisos em erros requer praticamente uma escotilha de escape para "não este, eu sei melhor que o compilador neste caso".

Muitas bibliotecas Java indispensáveis ​​nunca foram atualizadas para eliminar a necessidade de previsões inseguras. Suprimir esses avisos é necessário para que outros avisos mais importantes sejam notados e corrigidos.

Faço trabalho incorporado e me lembro de uma ou duas vezes em que desabilitei os avisos porque estava fazendo algo que parecia inútil para o compilador, mas que realmente tinha efeitos reais no hardware.

A única outra hora é quando estou trabalhando em bases de código com idéias díspares de alguma estrutura de dados (como como representar matrizes de bytes - char ou char não assinado?). Nesses casos, posso desativar os avisos, porque a alternativa é passar dias analisando o código e modificando uma parte ou colocando centenas de elencos.

Existem algumas razões para desativar seletivamente os avisos do compilador, mesmo para projetos que buscam melhores práticas.

• Compiladores diferentes (ou versões diferentes dos mesmos compiladores) : Os
  compiladores tratam os avisos de maneiras diferentes, com sutileza. Dando avisos de falso positivo que não afetam outros compiladores. Nesse caso, pode fazer sentido desabilitar o aviso para esses compiladores, em vez de editar o código válido para silenciar um aviso falso positivo que afeta apenas certos compiladores, especialmente para compiladores mais antigos que eventualmente não serão suportados de qualquer maneira.
• Com código gerado:
  Alguns avisos relacionados à higiene do código (código morto, corpo duplicado de instruções condicionais, comparações que excedem os limites de tipo) podem ser ignorados com segurança, pois são inofensivos e o compilador os otimizará.
  Gerar código que não gera esses avisos inofensivos também é uma opção, mas pode ser mais problemático do que vale a pena.
• Avisos para código externo:
  Talvez você use uma implementação conhecida da soma de verificação qsort ou md5, incluída no seu projeto. O código é usado por muitos projetos e conhecido por funcionar bem, mas pode haver alguns avisos exigentes que você normalmente corrige para o seu próprio código.
  No entanto, para código externo, pode ser menos trabalhoso desabilitar o aviso (supondo que ele definitivamente seja inofensivo).
• Avisos causados ​​por cabeçalhos do sistema:
  Embora o GCC / Clang, por exemplo -isystem, suporte , há casos em que as diferenças nos cabeçalhos do sistema causam avisos que podem ser ignorados (talvez uma função tenha um valor de retorno assinado em um sistema, mas não em outro), acionando -Wsign-compareavisos.
  Outro caso pode ser macros definidas nos cabeçalhos do sistema. Você pode copiar e colar as macros em seu próprio código para modificá-las, mas todas as coisas consideram melhor não ter que se preocupar em manter macros de bibliotecas de terceiros ... por isso é melhor apenas para acalmar o aviso (talvez a macro perca um elenco causando, -Wsign-conversionpor exemplo).
• Avisos não utilizados no código de stub:
  no entanto, você pode avisar sobre parâmetros não utilizados, ao remover uma biblioteca inteira em um único arquivo que contém apenas funções de stub - não é útil forçar (void)arg1; (void)arg2; (void)arg3; ...o corpo de todas as funções de stub.
  Melhor apenas suprimir -Wunused-parameterneste caso.

Note-se que em todos estes exemplos, a sua assumidos desabilitar os avisos não vai esconder erros reais, por exemplo: -Wredundant-decls, -Wunused-parameter, -Wdouble-promotion, talvez -Wpedantic... e que você sabe que você está fazendo!

Válido ou não, às vezes é feito para ignorar a diretiva "tratar avisos como erros" no servidor de compilação.

Fora isso, também não consigo pensar em nada. Os avisos desativados são geralmente um sinal de "feio feixe" ...

Na última vez em que desativamos certos avisos, foi porque um estagiário nos deixou com um código incorreto. Eu trabalhei muito melhor, com limites de conversão claros substituindo a representação de dados aleatória.

Enquanto isso, precisávamos compilá-lo e queríamos a opção "avisos são erros" ativada, então suprimimos alguns dos avisos.

Atualmente, o único aviso que eu ignoro é

  warning C4290: C++ exception specification ignored except to indicate a function is not __declspec(nothrow)  

Como a microsoft não implementa a especificação C ++ (a documentação diz que não!) E permite que as funções declarem lances específicos e todas as funções só podem lançar throw () ou throw (...), ou seja, nada ou tudo.

No HelpViewer 1.1:

 A function is declared using exception specification, which Visual C++ accepts but does not implement. Code with exception specifications that are ignored during compilation may need to be recompiled and linked to be reused in future versions supporting exception specifications.