Supporto per Apri cartella per i sistemi di compilazione C++ in Visual Studio

La funzionalità Apri cartella è disponibile in Visual Studio 2017 e versioni successive.

In Visual Studio 2017 e versioni successive la funzionalità "Apri cartella" consente di aprire una cartella di file di origine e avviare la codifica con il supporto di IntelliSense, esplorazione, refactoring, debug e così via. Man mano che si modificano, creano, spostano o eliminano file, Visual Studio tiene traccia automaticamente delle modifiche e aggiorna continuamente il relativo indice IntelliSense. Non viene caricato nessun file con estensione sln o vcxproj. Se necessario, è possibile specificare attività personalizzate e creare e avviare parametri mediante semplici file con estensione json. Questa funzionalità consente di integrare qualsiasi sistema di compilazione di terze parti in Visual Studio. Per informazioni generiche sulla funzionalità Apri cartella, vedere Sviluppare codice in Visual Studio senza progetti o soluzioni.

CMake e Qt

CMake è integrato nell'IDE di Visual Studio come componente del carico di lavoro desktop C++. Il flusso di lavoro per CMake non è identico al flusso di lavoro descritto in questo articolo. Se si usa CMake, vedere Progetti CMake in Visual Studio. È anche possibile usare CMake per compilare progetti Qt oppure usare l'estensione Qt di Visual Studio per Visual Studio 2015 o Visual Studio 2017.

Altri sistemi di compilazione

Per usare l'IDE di Visual Studio con un set di strumenti del compilatore o di sistema di compilazione non supportato direttamente dal menu principale, selezionare File | Apri | Cartella o premere CTRL+MAIUSC+ ALT+O. Passare alla cartella contenente i file di codice sorgente. Per compilare il progetto, configurare IntelliSense e impostare i parametri di debug, aggiungere tre file JSON:

Configurare lo spostamento del codice con CppProperties.json

Per il corretto funzionamento di IntelliSense e del comportamento di esplorazione, ad esempio Vai alla definizione , Visual Studio deve conoscere il compilatore in uso, dove si trovano le intestazioni di sistema e dove si trovano eventuali file di inclusione aggiuntivi se non si trovano direttamente nella cartella aperta (la cartella dell'area di lavoro). Per specificare una configurazione, è possibile scegliere Gestisci configurazioni dall'elenco a discesa nella barra degli strumenti principale:

Visual Studio offre le configurazioni predefinite seguenti:

Se, ad esempio, si sceglie x64-Debug, Visual Studio crea un file denominato CppProperties.json nella cartella del progetto radice:

{
  "configurations": [
    {
      "inheritEnvironments": [
        "msvc_x64"
      ],
      "name": "x64-Debug",
      "includePath": [
        "${env.INCLUDE}",
        "${workspaceRoot}\\**"
      ],
      "defines": [
        "WIN32",
        "_DEBUG",
        "UNICODE",
        "_UNICODE"
      ],
      "intelliSenseMode": "windows-msvc-x64"
    }
  ]
}

Questa configurazione eredita le variabili di ambiente del prompt dei comandi per sviluppatori di Visual Studio x64. Una di queste variabili è ed è INCLUDE possibile farvi riferimento qui usando la ${env.INCLUDE} macro . La includePath proprietà indica a Visual Studio dove cercare tutte le origini necessarie per IntelliSense. In questo caso, viene visualizzato "esaminare tutte le directory specificate dalla variabile di ambiente INCLUDE e anche tutte le directory nell'albero delle cartelle di lavoro corrente". La name proprietà è il nome che verrà visualizzato nell'elenco a discesa e può essere qualsiasi elemento desiderato. La defines proprietà fornisce suggerimenti a IntelliSense quando rileva blocchi di compilazione condizionale. La intelliSenseMode proprietà fornisce alcuni hint aggiuntivi in base al tipo di compilatore. Sono disponibili diverse opzioni per MSVC, GCC e Clang.

Configurazione predefinita per MinGW-w64

Se si aggiunge la configurazione MinGW-W64, il codice JSON avrà l'aspetto seguente:

{
  "configurations": [
    {
      "inheritEnvironments": [
        "mingw_64"
      ],
      "name": "Mingw64",
      "includePath": [
        "${env.INCLUDE}",
        "${workspaceRoot}\\**"
      ],
      "intelliSenseMode": "linux-gcc-x64",
      "environments": [
        {
          "MINGW64_ROOT": "C:\\msys64\\mingw64",
          "BIN_ROOT": "${env.MINGW64_ROOT}\\bin",
          "FLAVOR": "x86_64-w64-mingw32",
          "TOOLSET_VERSION": "9.1.0",
          "PATH": "${env.BIN_ROOT};${env.MINGW64_ROOT}\\..\\usr\\local\\bin;${env.MINGW64_ROOT}\\..\\usr\\bin;${env.MINGW64_ROOT}\\..\\bin;${env.PATH}",
          "INCLUDE": "${env.MINGW64_ROOT}\\include\\c++\\${env.TOOLSET_VERSION};${env.MINGW64_ROOT}\\include\\c++\\${env.TOOLSET_VERSION}\\tr1;${env.MINGW64_ROOT}\\include\\c++\\${env.TOOLSET_VERSION}\\${env.FLAVOR}",
          "environment": "mingw_64"
        }
      ]
    }
  ]
}

Prendere nota del environments blocco. Definisce le proprietà che si comportano come le variabili di ambiente e sono disponibili non solo nel file CppProperties.json , ma anche negli altri file di configurazione task.vs.json e launch.vs.json. La Mingw64 configurazione eredita l'ambiente mingw_w64 e usa la relativa INCLUDE proprietà per specificare il valore per includePath. È possibile aggiungere altri percorsi a questa proprietà della matrice in base alle esigenze".

La intelliSenseMode proprietà è impostata su un valore appropriato per GCC. Per altre informazioni su tutte queste proprietà, vedere Informazioni di riferimento sullo schema CppProperties.

Quando tutto funziona correttamente, viene visualizzato IntelliSense dalle intestazioni GCC quando si passa il puntatore del mouse su un tipo:

Abilitare la diagnostica di IntelliSense

Se non viene visualizzato IntelliSense previsto, è possibile risolvere i problemi passando a Strumenti>Opzioni>Editor>di testo C/C++>Avanzate e impostando Abilita registrazione su .true Per iniziare, provare a impostare Livello di registrazione su 5 e Filtri di registrazione su 8.

L'output viene inviato tramite pipe alla finestra di output ed è visibile quando si sceglie *Mostra output da: Log di Visual C++. L'output contiene, tra le altre cose, l'elenco dei percorsi di inclusione effettivi che IntelliSense sta tentando di usare. Se i percorsi non corrispondono a quelli in CppProperties.json, provare a chiudere la cartella ed eliminare la sottocartella .vs che contiene i dati di esplorazione memorizzati nella cache.

Definire le attività di compilazione con tasks.vs.json

È possibile automatizzare gli script di compilazione o qualsiasi altra operazione esterna per i file inclusi nell'area di lavoro corrente eseguendoli come attività direttamente nell'IDE. Per configurare una nuova attività, è possibile fare clic con il pulsante destro del mouse su un file o una cartella e scegliere Configura attività.

Verrà creato (o aperto) il file tasks.vs.json nella cartella vs creata da Visual Studio nella cartella del progetto radice. È possibile definire un'attività arbitraria in questo file, quindi chiamarla usando il nome specificato dal menu di scelta rapida Esplora soluzioni. Per continuare l'esempio GCC, il frammento di codice seguente mostra un file di tasks.vs.json completo con come singola attività che richiama g++.exe per compilare un progetto. Si supponga che il progetto contenga un singolo file denominato hello.cpp.

{
  "version": "0.2.1",
  "tasks": [
    {
      "taskLabel": "build hello",
      "appliesTo": "/",
      "type": "default",
      "command": "g++",
      "args": [
        "-g",
        "-o",
        "hello",
        "hello.cpp"
      ]
    }
  ]
}

Il file JSON viene inserito nella sottocartella .vs . Per visualizzare la cartella, fare clic sul pulsante Mostra tutti i file nella parte superiore di Esplora soluzioni. È possibile eseguire questa attività facendo clic con il pulsante destro del mouse sul nodo radice in Esplora soluzioni e scegliendo compila hello. Al termine dell'attività verrà visualizzato un nuovo file, hello.exe in Esplora soluzioni.

È possibile definire molti tipi di attività. L'esempio seguente mostra un file tasks.vs.json che definisce una singola attività. taskLabel definisce il nome visualizzato nel menu di scelta rapida. appliesTo definisce i file sui quali può essere eseguito il comando. La command proprietà fa riferimento alla variabile di ambiente COMSPEC, che identifica il percorso della console (cmd.exe in Windows). È anche possibile fare riferimento a variabili di ambiente che vengono dichiarate in CppProperties.json o CMakeSettings.json. La proprietà args specifica la riga di comando da chiamare. La macro ${file} recupera il file selezionato in Esplora soluzioni. Nell'esempio seguente viene visualizzato il nome del file con estensione cpp attualmente selezionato.

{
  "version": "0.2.1",
  "tasks": [
    {
      "taskLabel": "Echo filename",
      "appliesTo": "*.cpp",
      "type": "command",
      "command": "${env.COMSPEC}",
      "args": ["echo ${file}"]
    }
  ]
}

Dopo aver salvato tasks.vs.json, è possibile fare clic con il pulsante destro del mouse su qualsiasi file .cpp nella cartella, scegliere Nome file Echo dal menu di scelta rapida e visualizzare il nome del file visualizzato nella finestra Output.

Per altre informazioni, vedere Riferimento allo schema Tasks.vs.json.

Configurare i parametri di debug con launch.vs.json

Per personalizzare gli argomenti della riga di comando del programma e le istruzioni di debug, fare clic con il pulsante destro del mouse sul file eseguibile in Esplora soluzioni e selezionare Impostazioni debug e avvio. Verrà aperto un file di launch.vs.json esistente o, se non esiste, verrà creato un nuovo file con un set di impostazioni di avvio minime. Prima di tutto è possibile scegliere il tipo di sessione di debug che si vuole configurare. Per il debug di un progetto MinGw-w64, scegliamo Avvia C/C++ per MinGW/Cygwin (gdb). In questo modo viene creata una configurazione di avvio per l'uso di gdb.exe con alcune ipotesi istruite sui valori predefiniti. Uno di questi valori predefiniti è MINGW_PREFIX. È possibile sostituire il percorso letterale (come illustrato di seguito) oppure definire una MINGW_PREFIX proprietà in CppProperties.json:

{
  "version": "0.2.1",
  "defaults": {},
  "configurations": [
    {
      "type": "cppdbg",
      "name": "hello.exe",
      "project": "hello.exe",
      "cwd": "${workspaceRoot}",
      "program": "${debugInfo.target}",
      "MIMode": "gdb",
      "miDebuggerPath": "c:\\msys64\\usr\\bin\\gdb.exe",
      "externalConsole": true
    }
  ]
}

Per avviare il debug, scegliere l'eseguibile nell'elenco a discesa debug, quindi fare clic sulla freccia verde:

Verrà visualizzata la finestra di dialogo Inizializzazione del debugger e quindi una finestra della console esterna che esegue il programma.

Per altre informazioni, vedere informazioni di riferimento sullo schema launch.vs.json.

Avvio di altri eseguibili

È possibile definire le impostazioni di avvio per qualsiasi eseguibile nel computer. L'esempio seguente avvia 7za e specifica argomenti aggiuntivi, aggiungendoli alla args matrice JSON:

{
  "version": "0.2.1",
  "defaults": {},
  "configurations": [
    {
      "type": "default",
      "project": "CPP\\7zip\\Bundles\\Alone\\O\\7za.exe",
      "name": "7za.exe list content of helloworld.zip",
      "args": [ "l", "d:\\sources\\helloworld.zip" ]
    }
  ]
}

Quando si salva questo file, la nuova configurazione viene visualizzata nell'elenco a discesa Destinazione di debug ed è possibile selezionarla per avviare il debugger. È possibile creare il numero desiderato di configurazioni di debug, per un numero qualsiasi di file eseguibili. Se a questo punto si preme F5, il debugger viene avviato e raggiunge qualsiasi punto di interruzione già impostato. Tutte le finestre del debugger già note e le relative funzionalità sono ora disponibili.