Pulire C/C++ include in Visual Studio

• Propone di aggiungere file header al codice che viene compilato solo perché un file header necessario è incluso indirettamente da un altro file header.
• Offre la rimozione dei file di intestazione inutilizzati, migliorando i tempi di compilazione e la pulizia del codice.

La pulizia inclusa è disattivata per impostazione predefinita. Per informazioni su come configurarlo, vedere Config C/C++ Include Cleanup in Visual Studio.

Intestazioni dirette o indirette

Alcuni termini:

• Un header diretto è un header che inserisci esplicitamente #include nel tuo codice.
• Un'intestazione indiretta è inclusa perché è inclusa da un'intestazione che includi direttamente. È anche possibile dire che è inclusa transitivelyun'intestazione indiretta.

Include Cleanup analizza il codice e determina quali header non sono usati e quali sono inclusi indirettamente. Si consideri il file di intestazione seguente:

// myHeader.h

#include <string>
#include <iostream>

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

E il programma che lo usa:

// 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 è un'intestazione diretta perché myProgram.cpp la include in modo esplicito. myHeader.h include <string> e <iostream>, quindi queste sono intestazioni indirette.

Il problema è che myProgram.cpp usa std::string e std::cout, ma non include direttamente le intestazioni che le definiscono. Questo codice si compila perché myHeader.h include quegli header. Questo codice è fragile perché, se myHeader.h smettesse di includerne anche solo uno dei due, myProgram.cpp non verrebbe più compilato.

In base alle linee guida per C++, è preferibile includere in modo esplicito le intestazioni per tutte le dipendenze, in modo che il codice non sia soggetto alla fragilità causata dalle modifiche apportate ai file di intestazione. Per altre informazioni sulle linee guida, vedere SF.10: Evitare dipendenze da nomi d in modo #includeimplicito nelle linee guida di base di C++.

Include Cleanup analizza il codice per identificare gli header inutilizzati e inclusi indirettamente. Fornisce commenti e suggerimenti in base alle impostazioni descritte in Configurazione dello strumento di #include C++ in Visual Studio. Il feedback viene fornito sotto forma di avvisi dell'elenco degli errori e suggerimenti. Per maggiori dettagli sui riscontri forniti da Include Cleanup, vedere messaggi di Include Cleanup.

Intestazioni inutilizzate

Con l'evolversi del codice, alcuni file header potrebbero non essere più necessari. È difficile tenere traccia di queste intestazioni in un progetto complesso. Nel corso del tempo, le compilazioni potrebbero richiedere più tempo perché il compilatore elabora i file di intestazione non necessari. Include Cleanup consente di individuare e rimuovere i file di intestazione inutilizzati. Ad esempio, cosa accade se si imposta come commento myFunc() in 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
}

Nello screenshot seguente, #include "myHeader.h" appare disattivato (un'impostazione descritta in Configurare lo strumento #include di C++ in Visual Studio) perché non è più necessaria, dato che myFunc() è in commento.

Passa il cursore sull'elemento #include attenuato per aprire il menu delle azioni rapide. Selezionare la lampadina (o scegliere il collegamento Mostra potenziali correzioni ) per visualizzare le azioni correlate al file inutilizzato:

Aggiungere intestazioni usate in modo transitivo

È possibile scegliere di rimuovere il file di intestazione inutilizzato, ma l'azione interrompe il codice perché <string> e <iostream> sono inclusi indirettamente da myheader.h.

È invece possibile scegliere Aggiungi tutti i #includes usati transitivamente e rimuovi tutti i #includes inutilizzati. In questo modo viene rimossa l'intestazione inutilizzata myHeader.h, ma vengono aggiunte anche eventuali intestazioni usate indirettamente incluse tramite myHeader.h. Il risultato, in questo caso, consiste nell'aggiungere #include <string> e #include <iostream> a myProgram.cpp e nel rimuovere #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();
}

Lo strumento non aggiorna i commenti, ma puoi vedere che il codice ora usa direttamente std::string e std::cout. Questo codice non è più fragile perché non dipende più da myHeader.h per includere gli altri header necessari.

Procedura consigliata

Non rimuovere quelli che sembrano file header inutilizzati senza prima aggiungere i file header inclusi indirettamente. Il codice potrebbe basarsi su inclusioni indirette in un file header altrimenti inutilizzato. Aggiungete prima gli header utilizzati transitivamente. Quindi, quando si rimuovono le intestazioni inutilizzate, non si ricevono errori di compilazione a causa di file di intestazione mancanti inclusi indirettamente da un file di intestazione rimosso.

Quindi:

1. Nell'elenco degli errori verificare che il filtro sia impostato su Build + IntelliSense.
2. Cerca le occorrenze di "Il contenuto di #include x è utilizzato in questo file ed è incluso in modo transitivo".
3. Passare il cursore su una riga con il suggerimento. Nel menu a discesa della lampadina selezionare Aggiungi tutte le direttive include usate in modo transitivo.
4. Ripeti questi passaggi nel progetto finché non vengono risolti tutti questi suggerimenti relativi alle include transitive.
5. Rimuovere le include inutilizzate: nell'elenco degli errori cercare un'istanza di "#include x non viene usata in questo file".
6. Passare il cursore sull'intestazione inutilizzata. Dal menu a discesa della lampadina, seleziona Rimuovi tutte le include inutilizzate.
7. Ripeti questi passaggi nel tuo progetto finché non hai risolto tutti i suggerimenti di Include Cleanup.

In questa breve panoramica hai visto come Include Cleanup possa aiutarti a rimuovere gli header inutilizzati e ad aggiungere gli header inclusi indirettamente. Questo processo aiuta a mantenere il codice pulito, a compilare potenzialmente più velocemente e a ridurre la fragilità del tuo codice.

Vedi anche

Configurare la pulizia di inclusione C/C++ in Visual Studio
Includi messaggi di pulizia