Limpeza de inclusões de C/C++ no Visual Studio

A partir do Visual Studio 17.8 Preview 1, o Visual Studio fornece um #include recurso de limpeza que melhora a qualidade do seu código das seguintes maneiras:

• Sugere adicionar ficheiros de cabeçalho para código que compila apenas porque um ficheiro de cabeçalho necessário é incluído indiretamente por outro ficheiro de cabeçalho.
• Oferece remover arquivos de cabeçalho não utilizados - melhorando os tempos de construção e a claridade do código.

A opção 'Limpeza' está ativada por padrão. Para saber como configurá-lo, consulte Config C/C++ Include Cleanup in Visual Studio.

Cabeçalhos diretos vs indiretos

Em primeiro lugar, algumas terminologias:

• Um cabeçalho direto é um cabeçalho que você explicitamente #include em seu código.
• Um cabeçalho indireto é um cabeçalho que você não faz explicitamente #include. Em vez disso, um arquivo de cabeçalho que você inclui diretamente, inclui-o. Também dizemos que um cabeçalho indireto está incluído transitively.

Include Cleanup analisa seu código e determina quais cabeçalhos não são usados e quais são incluídos indiretamente. Considere o seguinte arquivo de cabeçalho:

// myHeader.h

#include <string>
#include <iostream>

void myFunc()
{
    std::string s = "myFunc()\n";
    std::cout << s;
}

E o programa que o utiliza:

// myProgram.cpp
#include "myHeader.h"

int main()
{
    std::string s = "main()"; // string is indirectly included by myHeader.h
    std::cout << s; // cout is indirectly included by myHeader.h
    myFunc();
}

myHeader.h é um cabeçalho direto porque myProgram.cpp o inclui explicitamente. myHeader.h inclui <string> e <iostream>, portanto, esses são cabeçalhos indiretos.

O problema é que myProgram.cpp usa std::string e std::cout, mas não inclui diretamente os cabeçalhos que os definem. Este código passa a compilar porque myHeader.h inclui esses cabeçalhos. Este código é frágil porque se myHeader.h alguma vez parasse de incluir qualquer um, myProgram.cpp não compilaria mais.

De acordo com as diretrizes do C++, é melhor incluir explicitamente cabeçalhos para todas as suas dependências para que seu código não esteja sujeito à fragilidade causada por alterações nos arquivos de cabeçalho. Para obter mais informações, consulte SF.10: Evitar dependências em nomes implicitamente definidos #include nas Diretrizes Principais do C++.

Include Cleanup analisa seu código para identificar cabeçalhos não utilizados e incluídos indiretamente. Ele fornece comentários com base nas configurações descritas em Config the C++ #include tool no Visual Studio. O feedback pode ser na forma de avisos de lista de erros, sugestões, etc. Para obter mais detalhes sobre o feedback fornecido por Include Cleanup, consulte Include Cleanup messages.

Cabeçalhos não utilizados

À medida que seu código evolui, você pode não precisar mais de alguns arquivos de cabeçalho. Isso é difícil de acompanhar em um projeto complexo. Com o tempo, suas compilações podem levar mais tempo porque o compilador está processando arquivos de cabeçalho desnecessários. A função Include Cleanup ajuda a localizar e remover cabeçalhos não utilizados. Por exemplo, e se o myFunc() estiver comentado no myProgram.cpp?

// myProgram.cpp
#include "myHeader.h"

int main()
{
    std::string s = "main()"; // string is indirectly included from myHeader.h
    std::cout << s; // cout is indirectly included from myHeader.h
    // myFunc(); // directly included from myHeader.h
}

Na captura de tela a seguir, #include "myHeader.h" está esmaecido (uma configuração descrita em Config the C++ #include tool in Visual Studio) porque não é usado desde que myFunc() é comentado.

Passe o cursor sobre o escurecido #include para abrir o menu de ação rápida. Clique na lâmpada (ou escolha o link Mostrar possíveis correções ) para ver as ações relacionadas ao arquivo não utilizado:

Adicionar cabeçalhos usados transitivamente

Poderíamos optar por remover o arquivo de cabeçalho não utilizado, mas isso quebra o código desde <string> e <iostream> são incluídos indiretamente via myheader.h.

Em vez disso, podemos escolher Adicionar todos os usados transitivamente e remover todos os #includes não utilizados. Isso remove o cabeçalho myHeader.hnão utilizado, mas também adiciona todos os cabeçalhos que estão sendo usados e que estão incluídos indiretamente via myHeader.h. O resultado, neste caso, é adicionar #include <string> e #include <iostream> para myProgram.cpp, e remover #include "myHeader.h":

// myProgram.cpp
#include <iostream>
#include <string>

int main()
{
    std::string s = "main()"; // string is directly included from <string>
    std::cout << s; // cout is directly included from <string>
    // MyFunc();
}

A ferramenta não atualiza os comentários, mas você pode ver que o código agora está usando std::string e std::cout diretamente. Este código já não é instável porque não depende de myHeader.h para incluir os outros cabeçalhos necessários.

Melhores práticas

Não remova o que parecem ser arquivos de cabeçalho não utilizados sem primeiro adicionar arquivos de cabeçalho incluídos indiretamente. Isso ocorre porque seu código pode depender de inclusões indiretas em um arquivo de cabeçalho que, de outra forma, não seria usado. Adicione cabeçalhos usados transitivamente primeiro. Em seguida, quando você remove cabeçalhos não utilizados, você não recebe erros de compilação devido a arquivos de cabeçalho ausentes que são incluídos indiretamente por um arquivo de cabeçalho que você removeu.

Uma maneira de fazer isso é definir a configuração Include Cleanup para Add missing includes suggestion level como Suggestion (Tools>Options>Text Editor>C/C++>Code Cleanup). Também defina Remover não utilizado inclui o nível de sugestão como Sugestão. Em seguida:

1. Na lista de erros, verifique se o filtro está definido como Build + IntelliSense.
2. Procure instâncias de "Conteúdo de #include x é usado neste arquivo e incluído transitivamente".
3. Passe o cursor sobre uma linha com a sugestão. No menu suspenso da lâmpada, selecione Adicionar todas as inclusões usadas transitivamente.
4. Repita essas etapas em seu projeto até que todas as sugestões sobre inclusões transitivas sejam abordadas.
5. Remover inclusões não utilizadas: na lista de erros, procure uma instância de "#include x não é usado neste arquivo".
6. Passe o cursor sobre o cabeçalho não utilizado. No menu pendente da lâmpada, selecione Remover todas as inclusões não utilizadas.
7. Repita estas etapas no seu projeto até que todas as sugestões de inclusão de limpeza sejam tratadas.

Neste breve resumo, pode-se ver como a funcionalidade "Limpeza de Inclusões" pode ajudar a remover cabeçalhos não utilizados e adicionar cabeçalhos que foram incluídos indiretamente. Isso ajuda você a manter seu código limpo, potencialmente criar mais rápido e reduz a fragilidade do seu código.

Ver também

Configurar a Limpeza de Inclusão de C/C++ no Visual Studio
Incluir mensagens de limpeza