A detecção de # supérfluos inclui em C / C ++?

Costumo achar que a seção de cabeçalhos de um arquivo fica cada vez maior o tempo todo, mas nunca fica menor. Ao longo da vida útil de um arquivo de origem, as classes podem ter sido movidas e refatoradas e é muito possível que existam algumas #includesque não precisem mais estar lá. Deixá-los lá apenas prolonga o tempo de compilação e adiciona dependências de compilação desnecessárias. Tentar descobrir quais ainda são necessários pode ser bastante entediante.

Existe algum tipo de ferramenta que pode detectar diretivas supérfluas #include e sugerir quais eu posso remover com segurança?
Talvez o fiapo faça isso?

Não é automático, mas o doxygen produzirá diagramas de dependência para #includedarquivos. Você precisará examiná-los visualmente, mas eles podem ser muito úteis para obter uma imagem do que está usando o quê.

O cppclean do Google (links para: download , documentação ) pode encontrar várias categorias de problemas de C ++ e agora pode encontrar #includes supérfluos.

Há também uma ferramenta baseada em Clang, que inclui o que você usa , que pode fazer isso. o include-you-use pode até sugerir declarações avançadas (para que você não precise #incluir muito) e, opcionalmente, limpar seus #includes para você.

As versões atuais do Eclipse CDT também têm essa funcionalidade embutida: ir no menu Origem e clicar em Organizar inclui, classificar seus # include's, adicionar cabeçalhos que o Eclipse achar que você está usando sem incluí-los diretamente e comentar os cabeçalhos que ele não usar acho que você precisa. Esse recurso não é 100% confiável, no entanto.

Verifique também o que você usa , que resolve um problema semelhante.

O problema com a detecção de inclusões supérfluas é que não pode ser apenas um verificador de dependência de tipo. Uma inclusão supérflua é um arquivo que não fornece nada de valor à compilação e não altera outro item do qual outros arquivos dependem. Existem várias maneiras de um arquivo de cabeçalho alterar uma compilação, digamos, definindo uma constante, redefinindo e / ou excluindo uma macro usada, adicionando um espaço para nome que altera a pesquisa de um nome de alguma forma na linha. Para detectar itens como o espaço para nome, você precisa muito mais do que um pré-processador, na verdade você quase precisa de um compilador completo.

O Lint é mais um verificador de estilo e certamente não terá esse recurso completo.

Eu acho que você encontrará a única maneira de detectar uma inclusão supérflua é remover, compilar e executar suítes.

Eu pensei que o PCLint faria isso, mas já faz alguns anos desde que eu olhei para ele. Você deveria conferir.

Eu olhei para este blog e o autor falou um pouco sobre como configurar o PCLint para encontrar inclusões não utilizadas. Pode valer a pena dar uma olhada.

O navegador de refatoração do CScout pode detectar diretivas de inclusão supérfluas no código C (infelizmente não C ++). Você pode encontrar uma descrição de como isso funciona neste artigo de jornal.

Você pode escrever um script rápido que apague uma única diretiva #include, compile os projetos e registre o nome na #include e o arquivo do qual foi removido no caso em que não ocorreram erros de compilação.

Deixe funcionar durante a noite e, no dia seguinte, você terá uma lista 100% correta dos arquivos de inclusão que você pode remover.

Às vezes, a força bruta simplesmente funciona :-)

edit: e às vezes não :-). Aqui estão algumas informações dos comentários:

1. Às vezes, você pode remover dois arquivos de cabeçalho separadamente, mas não os dois juntos. Uma solução é remover os arquivos de cabeçalho durante a execução e não trazê-los de volta. Ele encontrará uma lista de arquivos que você pode remover com segurança, embora possa haver uma solução com mais arquivos para remover, que esse algoritmo não encontrará. (é uma pesquisa gananciosa no espaço de inclusão de arquivos a serem removidos. Ele encontrará apenas um máximo local)
2. Pode haver alterações sutis no comportamento se você tiver algumas macros redefinidas de maneira diferente, dependendo de alguns #ifdefs. Penso que estes são casos muito raros, e os testes de unidade que fazem parte da compilação devem captar essas alterações.

Desculpe (re) postar aqui, as pessoas geralmente não expandem os comentários.

Verifique meu comentário para crashmstr, o FlexeLint / PC-Lint fará isso por você. Mensagem informativa 766. A seção 11.8.1 do meu manual (versão 8.0) discute isso.

Além disso, e isso é importante, continue iterando até que a mensagem desapareça . Em outras palavras, após remover os cabeçalhos não utilizados, reexecutar o fiapo, mais arquivos de cabeçalho podem se tornar "desnecessários" depois de remover alguns cabeçalhos desnecessários. (Isso pode parecer bobagem, leia-o devagar e analise-o, faz sentido.)

Eu nunca encontrei uma ferramenta completa que realize o que você está pedindo. A coisa mais próxima que usei é o IncludeManager , que representa graficamente sua árvore de inclusão de cabeçalho, para que você possa visualizar visualmente coisas como cabeçalhos incluídos em apenas um arquivo e inclusões circulares de cabeçalho.

Eu tentei usar o Flexelint (a versão unix do PC-Lint) e tive resultados um tanto mistos. Provavelmente porque estou trabalhando em uma base de código muito grande e complicada. Eu recomendo examinar cuidadosamente cada arquivo relatado como não utilizado.

A principal preocupação são os falsos positivos. Várias inclusões do mesmo cabeçalho são relatadas como um cabeçalho desnecessário. Isso é ruim, pois o Flexelint não informa em que linha o cabeçalho está incluído ou onde foi incluído antes.

Uma das maneiras pelas quais as ferramentas automatizadas podem errar:

Em A.hpp:

class A { 
  // ...
};

Em B.hpp:

#include "A.hpp

class B {
    public:
        A foo;
};

Em C.cpp:

#include "C.hpp"  

#include "B.hpp"  // <-- Unneeded, but lint reports it as needed
#include "A.hpp"  // <-- Needed, but lint reports it as unneeded

Se você seguir cegamente as mensagens do Flexelint, irá estragar suas #includes dependências. Existem mais casos patológicos, mas basicamente você precisará inspecionar os cabeçalhos para obter melhores resultados.

Eu recomendo este artigo sobre Estrutura Física e C ++ do blog Games de dentro. Eles recomendam uma abordagem abrangente para limpar a bagunça #include:

Diretrizes

Aqui está um conjunto destilado de diretrizes do livro de Lakos que minimizam o número de dependências físicas entre arquivos. Eu os uso há anos e sempre fiquei muito feliz com os resultados.

1. Todo arquivo cpp inclui primeiro seu próprio arquivo de cabeçalho. [recorte]
2. Um arquivo de cabeçalho deve incluir todos os arquivos de cabeçalho necessários para analisá-lo. [recorte]
3. Um arquivo de cabeçalho deve ter o número mínimo necessário de arquivos de cabeçalho necessários para analisá-lo. [recorte]

Se você estiver usando o Eclipse CDT, tente o http://includator.com, que é gratuito para testadores beta (no momento em que este artigo foi escrito) e remove automaticamente #includes supérfluos ou adiciona os ausentes. Para os usuários que possuem o FlexeLint ou PC-Lint e estão usando o Elicpse CDT, http://linticator.com pode ser uma opção (também gratuita para o teste beta). Enquanto usa a análise de Lint, fornece correções rápidas para remover automaticamente as instruções #include supérfluas.

Este artigo explica uma técnica de #include remover usando a análise de Doxygen. Esse é apenas um script perl, por isso é bastante fácil de usar.

Talvez um pouco tarde, mas uma vez encontrei um script perl do WebKit que fazia exatamente o que você queria. Acho que vai precisar de algumas adaptações (não sou muito versado em perl), mas deve fazer o truque:

http://trac.webkit.org/browser/branches/old/safari-3-2-branch/WebKitTools/Scripts/find-extra-includes

(este é um ramo antigo porque o tronco não possui mais o arquivo)

Existe uma ferramenta gratuita que inclui o File Dependencies Watcher, que pode ser integrado no visual studio. Mostra # supérfluo em vermelho.

Existem dois tipos de arquivos #include supérfluos:

1. Um arquivo de cabeçalho realmente não é necessário para o módulo (.c, .cpp)
2. Um arquivo de cabeçalho é necessário pelo módulo, mas está sendo incluído mais de uma vez, direta ou indiretamente.

Há duas maneiras na minha experiência que funcionam bem para detectá-lo:

• gcc -H ou cl.exe / showincludes (resolva o problema 2)

  No mundo real, você pode exportar CFLAGS = -H antes do make, se todos os Makefile não substituírem as opções CFLAGS. Ou, como eu usei, você pode criar um wrapper cc / g ++ para adicionar opções -H à força a cada chamada de $ (CC) e $ (CXX). e inclua o diretório do wrapper na variável $ PATH, então seu make utilizará o comando wrapper. Obviamente, seu wrapper deve chamar o compilador gcc real. Esses truques precisam ser alterados se o Makefile usar o gcc diretamente. em vez de $ (CC) ou $ (CXX) ou por regras implícitas.

  Você também pode compilar um único arquivo ajustando a linha de comando. Mas se você deseja limpar os cabeçalhos de todo o projeto. Você pode capturar toda a saída:

  fazer limpo

  faça 2> & 1 | tee result.txt

• PC-Lint / FlexeLint (resolva o problema 1 e 2)

  certifique-se de adicionar as opções + e766, este aviso é sobre: ​​arquivos de cabeçalho não utilizados.

  pclint / flint -vf ...

  Isso fará com que os arquivos de cabeçalho incluídos na saída pclint, os arquivos de cabeçalho aninhados sejam recuados adequadamente.

Para encerrar esta discussão: o pré-processador c ++ está completo. É uma propriedade semântica, se uma inclusão é supérflua. Portanto, segue-se do teorema de Rice que é indecidível se uma inclusão é supérflua ou não. Não pode haver um programa que (sempre corretamente) detecte se uma inclusão é supérflua.

Aqui está uma maneira simples de força bruta de identificar inclusões de cabeçalho supérfluas . Não é perfeito, mas elimina as inclusões desnecessárias "óbvias". Livrar-se deles ajuda bastante na limpeza do código.

Os scripts podem ser acessados ​​diretamente no GitHub.

O PC Lint da Gimpel Software pode relatar quando um arquivo de inclusão foi incluído mais de uma vez em uma unidade de compilação , mas não consegue encontrar arquivos de inclusão que não são necessários na maneira como você está procurando.

Edit: Pode. Veja a resposta de itsmatt

O CLion , o IDE C / C ++ do JetBrains, detecta inclusões redundantes prontas para uso. Eles estão acinzentados no editor, mas também existem funções para otimizar inclusões no arquivo atual ou no projeto inteiro .

Descobri que você paga por essa funcionalidade; O CLion leva um tempo para digitalizar e analisar seu projeto quando carregado pela primeira vez.