Configurare e compilare con i set di impostazioni di CMake in Visual Studio

CMake supporta due file che consentono agli utenti di specificare opzioni comuni di configurazione, compilazione e test e condividerle con altri utenti: CMakePresets.json e CMakeUserPresets.json. Usare questi file per eseguire l'unità CMake in Visual Studio e Visual Studio Code, in una pipeline di integrazione continua (CI) e dalla riga di comando.

CMakePresets.json è destinato al salvataggio di compilazioni a livello di progetto. CMakeUserPresets.json consente agli sviluppatori di salvare le proprie build locali. Entrambi i file sono supportati in Visual Studio 2019 versione 16.10 o successiva.

Questo articolo contiene informazioni sull'integrazione CMakePresets.json con Visual Studio. Ecco i collegamenti utili:

• Per altre informazioni sul formato di CMakePresets.json, vedere la documentazione ufficiale di CMake.
• Per altre informazioni sulle mappe dei fornitori Microsoft e sull'espansione delle macro, vedere CMakePresets.json e CMakeUserPresets.json Mappe dei fornitori Microsoft.
• Per altre informazioni su come usare CMakePresets.json in Visual Studio Code, vedere Configurare e compilare con i set di impostazioni di CMake.

È consigliabile CMakePresets.json come alternativa a CMakeSettings.json. Visual Studio non legge mai da e CMakePresets.jsonCMakeSettings.json contemporaneamente. Per abilitare o disabilitare CMakePresets.json l'integrazione in Visual Studio, vedere Abilitare CMakePresets.json in Visual Studio 2019.

CMake e CMakePresets.json versioni supportate

Le versioni supportate CMakePresets.json e CMakeUserPresets.json dello schema dipendono dalla versione di Visual Studio:

• Visual Studio 2019 versione 16.10 e successive supportano lo schema 2 e 3.
• Visual Studio 2022 versione 17.4 preview 1 aggiunge il supporto per lo schema versione 4.
• Visual Studio 2022 versione 17.5 preview 1 aggiunge il supporto per lo schema versione 5.

È possibile aggiornare la versione modificando il "version" campo nell'oggetto radice. Per un esempio e altre informazioni, vedere CMakePresets.json format.

CMake versione 3.20 o successiva è necessario quando si richiama CMake dalla CMakePresets.json riga di comando. Tuttavia, Visual Studio legge e valuta CMakePresets.json e CMakeUserPresets.json se stesso e non richiama CMake direttamente con l'opzione --preset . Pertanto, CMake versione 3.20 o successiva non è strettamente necessario quando si compila con CMakePresets.json all'interno di Visual Studio.

È consigliabile usare almeno CMake versione 3.14 o successiva.

Abilitare l'integrazione CMakePresets.json in Visual Studio

CMakePresets.json l'integrazione non è abilitata per impostazione predefinita in Visual Studio. È possibile abilitarlo in Strumenti>Opzioni>CMake>Generale:

Questa schermata viene raggiunta dal menu di Visual Studio 2022: Strumenti > Opzioni > CMake > Generale. L'opzione si trova nella sezione Configurare il file in CMake.

Importante

Chiudere e riaprire la cartella in Visual Studio per attivare l'integrazione.

In alcune versioni precedenti di Visual Studio, Tools>Options>CMake General include solo un'unica opzione per abilitare CMakePresets.json>l'integrazione:

La tabella seguente indica quando CMakePresets.json viene usato invece di per eseguire l'unità di CMakeSettings.json configurazione e compilazione CMake in Visual Studio 2022 e Visual Studio 2019 versione 16.10 e successive. Se non è presente alcun file di configurazione, vengono usati i set di impostazioni predefiniti predefiniti.

Nella tabella "Strumenti>opzioni abilitate" significa Usare CMakePresets.json per guidare la configurazione, la compilazione e il test di CMake selezionato in Strumenti>Opzioni>CMake>Generale.

File di configurazione	Opzioni strumenti > disabilitate	Opzioni strumenti > abilitate
Nessun file di configurazione presente	CMakeSettings.json	CMakePresets.json
CMakeSettings.json Presente	CMakeSettings.json	CMakePresets.json
CMakePresets.json Presente	CMakePresets.json	CMakePresets.json
Entrambi i file di configurazione presenti	CMakePresets.json	CMakePresets.json

Modificare la configurazione automatica e le notifiche della cache

Per impostazione predefinita, Visual Studio richiama configure automaticamente ogni volta che il sistema di destinazione attivo o configura le modifiche preimpostate. È possibile modificare questo comportamento selezionando Mai eseguire il passaggio configura automaticamente in Strumenti>Opzioni>CMake>Generale. È anche possibile disabilitare tutte le notifiche della cache CMake (barre oro) deselezionando Mostra notifiche della cache CMake.

Impostazione predefinita Configura set di impostazioni

Se non CMakePresets.json esiste alcun file o CMakeUserPresets.json o se CMakePresets.json o CMakeUserPresets.json non è valido, Visual Studio esegue il fallback nei set di impostazioni predefiniti seguenti:

Esempio per Windows

{
  "name": "windows-default",
  "displayName": "Windows x64 Debug",
  "description": "Sets Ninja generator, compilers, x64 architecture, build and install directory, debug build type",
  "generator": "Ninja",
  "binaryDir": "${sourceDir}/out/build/${presetName}",
  "architecture": {
    "value": "x64",
    "strategy": "external"
  },
  "cacheVariables": {
    "CMAKE_BUILD_TYPE": "Debug",
    "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}"
  },
  "vendor": {
    "microsoft.com/VisualStudioSettings/CMake/1.0": {
      "hostOS": [ "Windows" ]
    }
  }
},

Esempio per Linux

{
  "name": "linux-default",
  "displayName": "Linux Debug",
  "description": "Sets Ninja generator, compilers, build and install directory, debug build type",
  "generator": "Ninja",
  "binaryDir": "${sourceDir}/out/build/${presetName}",
  "cacheVariables": {
    "CMAKE_BUILD_TYPE": "Debug",
    "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}"
  },
  "vendor": {
    "microsoft.com/VisualStudioSettings/CMake/1.0": {
      "hostOS": [ "Linux" ]
    },
    "microsoft.com/VisualStudioRemoteSettings/CMake/1.0": {
      "sourceDir": "$env{HOME}/.vs/$ms{projectDirName}"
   }
  }
}

Se si tenta di aprire o modificare un CMakePresets.json file che non esiste, Visual Studio crea automaticamente un CMakePresets.json file con i set di impostazioni predefiniti nella radice del progetto.

Configurare e compilare

Sulla barra degli strumenti di Visual Studio sono disponibili elenchi a discesa per i sistemi di destinazione, Configura set di impostazioni e Compila preimpostazioni quando CMakePresets.json l'integrazione è abilitata:

Selezionare un sistema di destinazione

L'elenco a discesa a sinistra indica il sistema di destinazione attivo. Si tratta del sistema in cui viene richiamato CMake per configurare e compilare il progetto. Questo elenco a discesa include il computer locale, tutte le connessioni SSH in Gestione connessioni in base al nome host e tutte le installazioni di sottosistema Windows per Linux (WSL) disponibili in Visual Studio:

L'elenco a discesa contiene diverse voci, tra cui Computer locale, un indirizzo IP 192.168.0.5, WSL: ubuntu2004, WSL: debian e Manage Connessione ions.

Nell'esempio precedente:

• 192.168.0.5 è un sistema Linux remoto aggiunto a Gestione connessioni.
• ubuntu2004 e debian sono installazioni WSL.

Selezionare Gestisci Connessione ions per aprire Gestione connessioni.

Selezionare un set di impostazioni

L'elenco a discesa al centro indica il set di impostazioni di configurazione attivo. Si tratta del configurePreset valore usato quando CMake viene richiamato per generare il sistema di compilazione del progetto. Questo elenco a discesa include l'unione di set di impostazioni non nascosti definiti in CMakePresets.json e CMakeUserPresets.json.

Visual Studio usa il valore di hostOS in Microsoft Visual Studio Impostazioni mappa fornitore per nascondere Configura set di impostazioni che non si applicano al sistema di destinazione attivo. Per altre informazioni, vedere la voce relativa hostOS alla tabella in Visual Studio Impostazioni mappa fornitore.

Selezionare Gestisci configurazioni per aprire il CMakePresets.json file nella radice del progetto. CMakePresets.json viene creato se non esiste già.

Selezionare un set di impostazioni di compilazione

L'elenco a discesa a destra indica il set di impostazioni di compilazione attivo. Si tratta del buildPreset valore usato quando CMake viene richiamato per compilare il progetto. Questo elenco a discesa include l'unione di set di impostazioni di compilazione non nascosti definiti in CMakePresets.json e CMakeUserPresets.json.

Tutti i set di impostazioni di compilazione sono necessari per specificare un valore associato configurePreset . Visual Studio nasconde i set di impostazioni di compilazione che non si applicano al set di impostazioni di configurazione attivo. Per altre informazioni, vedere l'elenco dei set di impostazioni di compilazione.

Se non sono presenti set di impostazioni di compilazione associati al set di impostazioni di configurazione attivo, Visual Studio elenca il set di impostazioni di compilazione predefinito. Il set di impostazioni di compilazione cmake --build predefinito equivale a passare senza altri argomenti dalla riga di comando.

Configurazione

Visual Studio tenta automaticamente di configurare il progetto quando rileva che la cache CMake non è aggiornata. Per richiamare manualmente la configurazione, selezionare Project Configure project-name (Configura>< progetto-nome>) dal menu principale. Equivale all'esecuzione cmake --preset <configurePreset> dalla riga di comando, dove <configurePreset> è il nome del set di impostazioni di configurazione attivo.

Per disabilitare la generazione automatica della cache, vedere Configurazione automatica e notifiche della cache.

Creazione

Per compilare l'intero progetto, selezionare Compila>tutto dal menu principale. Equivale all'esecuzione cmake --build --preset <buildPreset> dalla riga di comando, dove <buildPreset> è il nome del set di impostazioni di compilazione attivo.

Per compilare una singola destinazione, passare alla visualizzazione Destinazioni CMake in Esplora soluzioni. Fare quindi clic con il pulsante destro del mouse su qualsiasi destinazione e scegliere Compila dal menu di scelta rapida.

Nota

Visual Studio 2019 non supporta l'opzione buildPresets.targets per compilare un subset di destinazioni specificate in CMakePresets.json.

Eseguire CTest

CMakePresets.json supporta due opzioni di menu in Visual Studio 2019:

• Esegui>test CTest per <project-name> richiama CTest ed esegue tutti i test associati all'impostazione predefinita e alla compilazione predefinita attiva, senza altri argomenti passati a CTest.
• Test>set di impostazioni di esecuzione test per <configurePreset> si espande per visualizzare tutti i set di impostazioni di test associati al set di impostazioni di configurazione attivo. La selezione di un singolo set di impostazioni di test equivale all'esecuzione ctest --preset <testPreset> dalla riga di comando, dove <testPreset> è il nome del set di impostazioni di test selezionato. Questa opzione non è disponibile se non sono definiti set di impostazioni di test per il set di impostazioni di configurazione attivo.

In Visual Studio 2019 Esplora test non è integrato con CMakePresets.json.

Aggiungere nuovi set di impostazioni

In Visual Studio 2019 tutti i comandi e i modelli predefiniti modificano CMakePresets.json. È possibile aggiungere nuovi set di impostazioni a livello di utente modificando CMakeUserPresets.jsondirettamente .

Usare una barra (/) per i percorsi in CMakePresets.json e CMakeUserPresets.json.

Aggiungere nuovi set di impostazioni di configurazione

Per aggiungere un nuovo set di impostazioni a CMakePresets.json, da Esplora soluzioni fare clic con il pulsante destro del mouse CMakePresets.json in Visualizzazione cartelle e scegliere Aggiungi configurazione dal menu di scelta rapida. Verrà visualizzata la finestra di dialogo per selezionare un modello preimpostato:

Selezionare il modello debug di Windows x64 da configurare nei sistemi Windows. Selezionare il modello Debug Linux da configurare nei sistemi WSL e Linux remoti. Per altre informazioni sulla modifica CMakePresets.jsondi , vedere Modificare i set di impostazioni.

Il modello selezionato viene aggiunto a CMakePresets.json , se esistente. In caso contrario, il modello viene copiato in un nuovo CMakePresets.json file.

Aggiungere nuovi set di impostazioni di compilazione e set di impostazioni di test

Visual Studio 2019 non offre modelli per i nuovi set di impostazioni di compilazione e set di impostazioni di test. È possibile aggiungere set di impostazioni di compilazione e set di impostazioni di test modificando CMakePresets.jsondirettamente . Per altre informazioni, vedere l'elenco dei set di impostazioni di compilazione, l'elenco dei set di impostazioni di test o un file di esempioCMakePresets.json.

Modificare i set di impostazioni

La documentazione ufficiale di CMake è la risorsa migliore per la modifica di Set di impostazioni di configurazione, set di impostazioni di compilazione e set di impostazioni di test. Le informazioni seguenti sono un subset della documentazione di CMake particolarmente rilevante per gli sviluppatori di Visual Studio.

Selezionare i compilatori

È possibile impostare compilatori C e C++ usando cacheVariables.CMAKE_C_COMPILER e cacheVariables.CMAKE_CXX_COMPILER in un set di impostazioni di configurazione. Equivale a passare -D CMAKE_C_COMPILER=<value> e -D CMAKE_CXX_COMPILER=<value> a CMake dalla riga di comando. Per ulteriori informazioni, vedere CMAKE_<LANG>_COMPILER.

Usare gli esempi seguenti per compilare con cl.exe e clang-cl.exe da Visual Studio. Gli strumenti Clang C++ per i componenti di Windows devono essere installati per la compilazione con clang-cl.

Compilare con cl.exe:

"cacheVariables": {
  "CMAKE_BUILD_TYPE": "Debug",
  "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}",
  "CMAKE_C_COMPILER": "cl",
  "CMAKE_CXX_COMPILER": "cl"
},

Compilare con clang:

"cacheVariables": {
  "CMAKE_BUILD_TYPE": "Debug",
  "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}",
  "CMAKE_C_COMPILER": "clang-cl",
  "CMAKE_CXX_COMPILER": "clang-cl"
},

"vendor": {
  "microsoft.com/VisualStudioSettings/CMake/1.0": {
    "intelliSenseMode": "windows-clang-x64"
  }
}

Se si usa Visual Studio 16 2019 o Visual Studio 17 2022 come generatore, è possibile usare il toolset set di impostazioni Configura per specificare il ClangCL set di strumenti:

"cacheVariables": {
  "CMAKE_BUILD_TYPE": "Debug",
  "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}",
},

"toolset": "ClangCL",

"vendor": {
  "microsoft.com/VisualStudioSettings/CMake/1.0": {
    "intelliSenseMode": "windows-clang-x64"
  }
}

Per altre informazioni sui generatori che supportano la toolset specifica, vedere CMAKE_GENERATOR_TOOLSET la documentazione di CMake.

Importante

In Visual Studio 2019 è necessario specificare in modo esplicito una modalità IntelliSense Clang durante la compilazione con clang o clang-cl.

Per riprodurre queste compilazioni all'esterno di Visual Studio, vedere Eseguire CMake dalla riga di comando o da una pipeline CI.

Per compilare in Linux o senza il set di strumenti di Visual C++, specificare il nome di un compilatore nell'istanza PATH o una variabile di ambiente che restituisce il percorso completo di un compilatore. I percorsi completi sono sconsigliati in modo che il file possa rimanere condivisibile. Un set di impostazioni compilato con GCC versione 8 potrebbe essere simile al seguente:

"cacheVariables": {
  "CMAKE_BUILD_TYPE": "Debug",
  "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}",
  "CMAKE_C_COMPILER": "gcc-8",
  "CMAKE_CXX_COMPILER": "g++-8"
},

È anche possibile impostare i compilatori con un file toolchain CMake. I file toolchain possono essere impostati con cacheVariables.CMAKE_TOOLCHAIN_FILE, che equivale a passare -D CMAKE_TOOLCHAIN_FILE=<value> a CMake dalla riga di comando. Un file toolchain CMake viene spesso usato per la compilazione incrociata. Per altre informazioni sulla creazione di file toolchain CMake, vedere Toolchain CMake.

Selezionare il generatore

I modelli preimpostati di Windows e Linux specificano entrambi Ninja come generatore predefinito. Altri generatori comuni sono i generatori di Visual Studio in Windows e Unix Makefiles in Linux e macOS. È possibile specificare un nuovo generatore con l'opzione generator in un set di impostazioni Di configurazione. Equivale a passare -G a CMake dalla riga di comando.

Impostare architecture.strategy e toolset.strategy su set quando si compila con un generatore di Visual Studio. Per altre informazioni, vedere Generatori CMake.

Selezionare il tipo di configurazione

È possibile impostare il tipo di configurazione (Debug o Release) per i singoli generatori di configurazione usando cacheVariables.CMAKE_BUILD_TYPE. Equivale a passare -D CMAKE_BUILD_TYPE=<value> a CMake dalla riga di comando. Per ulteriori informazioni, vedere CMAKE_BUILD_TYPE.

Selezionare l'architettura di destinazione e host durante la compilazione con il set di strumenti di Visual C++

È possibile impostare l'architettura di destinazione (x64, Win32, ARM64 o ARM) usando architecture.value. Equivale a passare -A a CMake dalla riga di comando. Per altre informazioni, vedere Selezione della piattaforma.

Nota

Attualmente, i generatori di Visual Studio prevedono la sintassi Win32 e i generatori da riga di comando (come Ninja) prevedono la sintassi x86 durante la compilazione per x86.

È possibile impostare l'architettura host (x64 o x86) e il set di strumenti usando toolset.value. Equivale a passare -T a CMake dalla riga di comando. Per altre informazioni, vedere Selezione set di strumenti.

I architecture.strategy valori e toolset.strategy indicano a CMake come gestire i campi dell'architettura e del set di strumenti. set indica che CMake imposta il rispettivo valore e external indica che CMake non imposta il rispettivo valore.

È consigliabile usare set con generatori di IDE come Visual Studio Generator. Usare external con generatori da riga di comando come Ninja. Questi valori consentono ai fornitori come Visual Studio di fornire l'ambiente necessario prima che venga richiamato CMake. Per altre informazioni sui campi architettura e set di strumenti, vedere l'elenco di Configura set di impostazioni.

Se non si vuole eseguire l'origine di un ambiente, è possibile impostare su architecture.strategyexternal e architecture.value su unspecified. Potrebbe risultare utile non generare un ambiente per uno di questi motivi:

• Si usa un set di strumenti diverso da MSVC.
• Si usa una toolchain personalizzata, ad esempio negli scenari incorporati.
• Non è necessario un ambiente specifico da compilare.

Per un elenco completo dei generatori di IDE che supportano il campo architettura, vedere CMAKE_GENERATOR_PLATFORM. Per un elenco completo dei generatori di IDE che supportano il campo set di strumenti, vedere CMAKE_GENERATOR_TOOLSET.

Usare gli esempi seguenti per usare ARM64 con il generatore Ninja o win32 (x86) con il generatore di Visual Studio 16 2019:

"generator": "Ninja",
"architecture": {
    "strategy": "external",
    "value": "arm64"
},

"generator": "Visual Studio 16 2019",
"architecture": {
    "strategy": "set",
     "value": "Win32"
},

Impostare e fare riferimento alle variabili di ambiente

È possibile impostare le variabili di ambiente usando la mappa dell'ambiente. Le variabili di ambiente vengono ereditate tramite il inherits campo , ma è possibile eseguirne l'override nel modo desiderato.

L'ambiente di un set di impostazioni è l'unione del proprio ambiente e dell'ambiente di tutti i genitori. Se più inherits set di impostazioni forniscono valori in conflitto per la stessa variabile, è preferibile usare il set di impostazioni precedente nell'elenco inherits . È possibile annullare l'impostazione di una variabile ereditata da un altro set di impostazioni impostandola su null.

Le variabili di ambiente impostate in un set di impostazioni di configurazione passano automaticamente anche ai set di impostazioni di compilazione e ai set di impostazioni di test associati, a meno che non inheritConfigureEnvironment sia impostato su false. Per altre informazioni, vedere l'elenco configura set di impostazioni.

È possibile fare riferimento alle variabili di ambiente usando la $env{<variable-name>} sintassi e $penv{<variable-name>} . Per altre informazioni, vedere Espansione macro.

Configurare IntelliSense per un compilatore incrociato

Per impostazione predefinita, Visual Studio usa la modalità IntelliSense corrispondente al set di strumenti e all'architettura di destinazione specificati. Se si esegue la compilazione incrociata, potrebbe essere necessario specificare manualmente la modalità IntelliSense corretta usando l'opzione intelliSenseMode nella mappa del fornitore di Visual Studio Impostazioni. Per altre informazioni, vedere la voce relativa intelliSenseMode alla tabella in Visual Studio Impostazioni mappa fornitore.

Configurare e compilare un sistema remoto o il sottosistema Windows per Linux

Con CMakePresets.json il supporto in Visual Studio, è possibile configurare e compilare facilmente il progetto in sistemi Windows, WSL e remoti. I passaggi per configurare e compilare il progetto in Windows, un sistema remoto o WSL sono gli stessi. Tuttavia, alcuni comportamenti sono specifici dello sviluppo remoto.

${sourceDir} comportamento in scenari di copia remota

Negli scenari locali (incluso WSL1), ${sourceDir} restituisce il percorso della directory di origine del progetto aperta in Visual Studio. Negli scenari di copia remota, ${sourceDir} restituisce il percorso della directory di origine del progetto nel sistema di destinazione e non la directory di origine del progetto nel computer locale.

Il valore di sourceDir nella mappa fornitore di Visual Studio Remote Impostazioni determina la directory di origine del progetto nel sistema di destinazione (per impostazione predefinita è $env{HOME}/.vs/$ms{projectDirName}). Per altre informazioni, vedere la voce relativa sourceDir alla tabella in Visual Studio Impostazioni mappa fornitore.

Cartella locale per l'output remoto

Gli scenari di copia remota richiedono una directory locale per copiare alcuni file remoti come i file di risposta dell'API file CMake o i file di compilazione se copyBuildOutput nella mappa del fornitore di Visual Studio Remote Impostazioni è impostato su true. Questi file vengono copiati automaticamente in <local-source-directory>/out/<remote-connection-ID>/build/${presetName}.

Richiamo dello stesso set di impostazioni in Windows e WSL1

Se si prova a usare lo stesso set di impostazioni in Windows e WSL1, verrà visualizzato un errore. Windows e WSL1 usano entrambi il file system Windows, quindi CMake tenterà di usare la stessa directory di output (binaryDir) sia per gli alberi di compilazione Windows che WSL1.

Se si vuole usare lo stesso set di impostazioni configura con Windows e il set di strumenti WSL1, creare un secondo set di impostazioni configura che eredita dal set di impostazioni originale e specifica un nuovo binaryDir valore. Nell'esempio seguente, windows-preset può essere usato in Windows e base-preset può essere usato in WSL1:

{
  "name": "windows-preset",
  "inherits": "base-preset",
  "binaryDir": "${sourceDir}/out/build/${presetName}",
  "vendor": {
    "microsoft.com/VisualStudioSettings/CMake/1.0": {
      "hostOS": "Windows"
    }
  }
}

Nota

In Visual Studio 2019 è supportato solo il set di strumenti WSL1. Questo comportamento verrà visualizzato ogni volta che si richiama configure sia in Windows che in WSL.

Abilitare l'integrazione di vcpkg

Vcpkg consente di gestire le librerie C e C++ in Windows, Linux e macOS. Per abilitare l'integrazione vcpkg, è necessario passare un file toolchain vcpkg () avcpkg.cmake CMake. Per altre informazioni, vedere la documentazione di vcpkg.

Visual Studio non passa più il file toolchain vcpkg a CMake automaticamente quando CMakePresets.json l'integrazione è abilitata. Questa modifica elimina il comportamento specifico di Visual Studio e garantisce che sia possibile riprodurre la compilazione dalla riga di comando.

Impostare invece il percorso su vcpkg.cmake usando la VCPKG_ROOT variabile di ambiente in CMakePresets.json:

"cacheVariables": {
   "CMAKE_TOOLCHAIN_FILE": {
      "value": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake",
       "type": "FILEPATH"
    }
 },

VCPKG_ROOT deve essere impostato sulla radice dell'installazione di vcpkg. Per altre informazioni, vedere variabili di ambiente vcpkg.

Se si usa già un file toolchain CMake e si vuole abilitare l'integrazione vcpkg, vedere Uso di più file toolchain. Seguire queste istruzioni per usare un file toolchain esterno con un progetto usando vcpkg.

Sostituzione di variabili in launch.vs.json e tasks.vs.json

CMakePresets.json supporta la sostituzione delle variabili in launch.vs.json e tasks.vs.json. Ecco alcune considerazioni:

• Le variabili di ambiente impostate nel set di impostazioni attivo passano automaticamente a launch.vs.json e tasks.vs.json le configurazioni. È possibile annullare l'impostazione di singole variabili di ambiente in launch.vs.json e tasks.vs.json impostandole su null. Nell'esempio seguente la variabile viene null impostata DEBUG_LOGGING_LEVEL su in launch.vs.json: "env": { "DEBUG_LOGGING_LEVEL": null }.

• I valori chiave impostati nel set di impostazioni configura attivo sono disponibili per l'utilizzo in launch.vs.json e tasks.vs.json con la sintassi ${cmake.<KEY-NAME>}. Ad esempio, usare ${cmake.binaryDir} per fare riferimento alla directory di output del set di impostazioni di configurazione attivo.

• Le singole variabili di ambiente impostate nella mappa dell'ambiente del set di impostazioni configura attivo sono disponibili per l'utilizzo in launch.vs.json e tasks.vs.json tramite la sintassi ${env.<VARIABLE-NAME>}.

Aggiornare i launch.vs.json file e task.vs.json in modo che facciano riferimento CMakePresets.json alla sintassi anziché alla CMakeSettings.json sintassi. Le macro che fanno riferimento alla sintassi precedente CMakeSettings.json quando CMakePresets.json è il file di configurazione attivo sono correlate alla deprecazione in una versione futura. Ad esempio, fare riferimento alla directory di output dell'impostazione predefinita attiva con ${cmake.binaryDir} anziché ${cmake.buildRoot}a , perché CMakePresets.json usa la binaryDir sintassi .

Risoluzione dei problemi

Se gli elementi non funzionano come previsto, è possibile provare alcuni passaggi per la risoluzione dei problemi.

CMakePresets.json Se o CMakeUserPresets.json non è valido, Visual Studio eseguirà il fallback sul comportamento predefinito e visualizzerà solo i set di impostazioni predefiniti predefiniti. Visual Studio IntelliSense consente di rilevare molti di questi errori JSON, ma non saprà se si fa riferimento a un set di impostazioni con inherits o configurePreset con il nome errato.

Per verificare se i file predefiniti sono validi, eseguire cmake --list-presets dalla riga di comando nella radice della directory del progetto. (È necessario CMake 3.20 o versione successiva). Se uno dei due file non è valido, verrà visualizzato l'errore seguente:

CMake Error: Could not read presets from
C:/Users/<user>/source/repos/<project-name>: JSON parse error

Altri passaggi per la risoluzione dei problemi includono:

• Eliminare la cache e riconfigurare il progetto (CMake: Delete Cache and Project>Configure <project-name>).
• Chiudere e riaprire la cartella in Visual Studio (cartella chiudi file>).
• Eliminare la .vs cartella nella radice del progetto.

Se è stato identificato un problema, il modo migliore per segnalarlo consiste nel selezionare il pulsante Invia commenti e suggerimenti nell'angolo superiore destro di Visual Studio.

Abilitare la registrazione per le connessioni remote

È possibile abilitare la registrazione per le connessioni remote in caso di problemi di connessione o copia di file in un sistema remoto. Per altre informazioni, vedere Registrazione per le connessioni remote.

Abilitare AddressSanitizer per Windows e Linux

Visual Studio supporta AddressSanitizer (ASAN), un rilevatore di errori di memoria di runtime C e C++ per lo sviluppo di Windows e Linux. L'opzione addressSanitizerEnabled in CMakeSettings.json abilita AddressSanitizer. CMakePresets.json non supporta questo comportamento.

Abilitare e disabilitare invece AddressSanitizer impostando manualmente i flag del compilatore e del linker necessari. L'impostazione rimuove il comportamento specifico di Visual Studio e garantisce che lo stesso CMakePresets.json file possa riprodurre la compilazione dalla riga di comando.

È possibile aggiungere l'esempio seguente per CMakeLists.txt abilitare o disabilitare AddressSanitizer per una destinazione:

option(ASAN_ENABLED "Build this target with AddressSanitizer" ON)

if(ASAN_ENABLED)
  if(MSVC)
    target_compile_options(<target> PUBLIC /fsanitize=address)
  else()
    target_compile_options(<target> PUBLIC -fsanitize=address <additional-options>)
    target_link_options(<target> PUBLIC -fsanitize=address)
  endif()
endif()

Nella <additional-options> parte sono elencati altri flag di compilazione, ad esempio "-fno-omit-frame-pointer". Per altre informazioni su AddressSanitizer per Linux, vedere Uso di AddressSanitizer. Per altre informazioni sull'uso di AddressSanitizer con MSVC, vedere Usare AddressSanitizer da un prompt dei comandi per sviluppatori.

Passare i flag di runtime a AddressSanitizer usando il ASAN_OPTIONS campo in launch.vs.json. ASAN_OPTIONS l'impostazione predefinita è detect_leaks=0 quando non vengono specificate altre opzioni di runtime perché LeakSanitizer non è supportato in Visual Studio.

Eseguire CMake dalla riga di comando o da una pipeline CI

È possibile usare gli stessi CMakePresets.json file e CMakeUserPresets.json per richiamare CMake in Visual Studio e dalla riga di comando. La documentazione di CMake e CTest sono le risorse migliori per richiamare CMake e CTest con --preset. È necessario CMake versione 3.20 o successiva.

Origine dell'ambiente durante la compilazione con generatori da riga di comando in Windows

Spetta all'utente configurare l'ambiente prima che CMake venga richiamato nella compilazione con un generatore da riga di comando. Se si compila con Ninja e il set di strumenti di Visual C++ in Windows, impostare l'ambiente prima che venga chiamato CMake per generare il sistema di compilazione. È possibile farlo chiamando vcvarsall.bat con l'argomento architecture . L'argomento architecture specifica l'architettura host e di destinazione da usare. Per altre informazioni, vedere vcvarsall sintassi. Se si esegue la compilazione in Linux o in Windows con un generatore di Visual Studio, non è necessario eseguire questo passaggio.

È lo stesso passaggio che Visual Studio richiede quando l'IDE richiama CMake. Visual Studio analizza il set di impostazioni di configurazione attivo per l'architettura host e di destinazione specificata da toolset e architecture. Visual Studio quindi esegue l'origine dell'ambiente specificato da vcvarsall.bat. Quando si esegue la compilazione dalla riga di comando di Windows con Ninja, è necessario eseguire questo passaggio manualmente.

vcvarsall.bat viene installato con Build Tools per Visual Studio. Per impostazione predefinita, vcvarsall.bat è installato in C:\Program Files (x86)\Microsoft Visual Studio\2019\<edition>\VC\Auxiliary\Build. È possibile aggiungere vcvarsall.bat a PATH se si usa spesso il flusso di lavoro della riga di comando.

Flusso di lavoro della riga di comando di esempio

È possibile usare i comandi seguenti per configurare e compilare un progetto CMake che usa Ninja per usare ARM64 con strumenti di compilazione x64. È necessario CMake versione 3.20 o successiva. Eseguire questi comandi dalla directory in cui si trova il CMakePresets.json file:

/path/to/vcvarsall.bat x64_arm64 
cmake --list-presets=all .
cmake --preset <configurePreset-name>
cmake --build --preset <buildPreset-name> 

File di esempio CMakePresets.json

Il CMakePresets.json file in box2d-lite contiene esempi di Configurare set di impostazioni, set di impostazioni di compilazione e set di impostazioni di test. Per altre informazioni su questo esempio, vedere la presentazione Introduzione a CMakePresets.json. È possibile visualizzare un altro esempio nel progetto DirectXTK , che mostra molte destinazioni di compilazione nella relativa configurePresets sezione.

Passaggi successivi

Altre informazioni sulla configurazione e il debug di progetti CMake in Visual Studio:

Progetti CMake in Visual Studio
Personalizzare le impostazioni di compilazione di CMake
Configurare le sessioni di debug di CMake
Informazioni di riferimento sulle configurazioni predefinite CMake