Dela via

Konfigurera och skapa med CMake-förinställningar i Visual Studio

CMake stöder två filer som gör det möjligt för användare att ange vanliga konfigurations-, bygg- och testalternativ och dela dem med andra: CMakePresets.json och CMakeUserPresets.json. Använd dessa filer för att köra CMake i Visual Studio och Visual Studio Code, i en CI-pipeline (kontinuerlig integrering) och från kommandoraden.

CMakePresets.json är till för att spara projektomfattande versioner. CMakeUserPresets.json är till för utvecklare att spara sina egna lokala byggen. Båda filerna stöds i Visual Studio 2019 version 16.10 eller senare.

Den här artikeln innehåller information om CMakePresets.json integrering med Visual Studio. Här är användbara länkar:

Vi rekommenderar CMakePresets.json som ett alternativ till CMakeSettings.json. Visual Studio läser aldrig från både CMakePresets.json och CMakeSettings.json samtidigt. Information om hur du aktiverar eller inaktiverar CMakePresets.json integrering i Visual Studio finns i Aktivera CMakePresets.json i Visual Studio 2019.

CMake och CMakePresets.json versioner som stöds

Vilka versioner som stöds CMakePresets.json och CMakeUserPresets.json scheman beror på din version av Visual Studio:

  • Visual Studio 2019 version 16.10 och senare stöder schemaversion 2 och 3.
  • Visual Studio 2022 version 17.4 preview 1 lägger till stöd för schemaversion 4.
  • Visual Studio 2022 version 17.5 preview 1 lägger till stöd för schemaversion 5.

Du kan uppdatera versionen genom att ändra fältet "version" i rotobjektet. Ett exempel och mer information finns i CMakePresets.json format.

CMake version 3.20 eller senare krävs när du anropar CMake med CMakePresets.json från kommandoraden. Visual Studio läser och utvärderar och anropar CMakePresets.jsonCMakeUserPresets.json dock inte CMake direkt med --preset alternativet . Därför krävs inte CMake version 3.20 eller senare när du skapar med CMakePresets.json i Visual Studio.

Vi rekommenderar att du använder minst CMake version 3.14 eller senare.

Aktivera CMakePresets.json integrering i Visual Studio

CMakePresets.json integrering är inte aktiverat som standard i Visual Studio. Du kan aktivera den i Verktygsalternativ>>CMake>Allmänt:

Skärmbild som visar

Viktigt!

Stäng och öppna mappen i Visual Studio igen för att aktivera integreringen.

I vissa äldre versioner av Visual Studio har verktygsalternativ>>CMake>General bara ett enda alternativ för att aktivera CMakePresets.json integrering:

Skärmbild av en äldre version av Visual Studio. Det finns en kryssruta med etiketten

Följande tabell anger när CMakePresets.json används i stället för CMakeSettings.json att köra CMake-konfiguration och skapa i Visual Studio 2022 och Visual Studio 2019 version 16.10 och senare. Om det inte finns någon konfigurationsfil används standardinställningen Konfigurera förinställningar.

I tabellen betyder "Verktygsalternativ> aktiverade" använd CMakePresets.json för att köra CMake konfigurera, skapa och testa väljs iVerktygsalternativ>>CMake>Allmänt.

Konfigurationsfiler Verktygsalternativ > inaktiverade Verktygsalternativ > aktiverade
Ingen konfigurationsfil finns CMakeSettings.json CMakePresets.json
CMakeSettings.json gåva CMakeSettings.json CMakePresets.json
CMakePresets.json gåva CMakePresets.json CMakePresets.json
Båda konfigurationsfilerna finns CMakePresets.json CMakePresets.json

Ändra automatiska konfigurations- och cachemeddelanden

Som standard anropar configure Visual Studio automatiskt varje gång det aktiva målsystemet eller Konfigurera förinställning ändras. Du kan ändra det här beteendet genom att välja Kör aldrig konfigurera steg automatiskt iVerktygsalternativ>>CMake>Allmänt. Du kan också inaktivera alla CMake-cachemeddelanden (guldstaplar) genom att rensa Visa CMake-cachemeddelanden.

Standardkonfigurering av förinställningar

Om det inte finns någon CMakePresets.json fil, CMakeUserPresets.json eller om CMakePresets.json eller CMakeUserPresets.json är ogiltig, återgår Visual Studio till följande standardinställning konfigurera förinställningar:

Windows-exempel

{
  "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" ]
    }
  }
},

Linux-exempel

{
  "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}"
   }
  }
}

Om du försöker öppna eller ändra en CMakePresets.json fil som inte finns skapar Visual Studio automatiskt en CMakePresets.json fil med standardinställningen Konfigurera förinställningar i roten av projektet.

Konfigurera och skapa

I Visual Studio-verktygsfältet finns listrutor för Målsystem, Konfigurera förinställningar och Skapa förinställningar när CMakePresets.json integrering är aktiverat:

Skärmbild som visar listrutorna för målsystemet inställt på Lokal dator, konfigurationsinställningen windows-arm64 och förinställningen build inställd på standard.

Välj ett målsystem

Listrutan till vänster anger det aktiva målsystemet. Det är systemet där CMake anropas för att konfigurera och skapa projektet. Den här listrutan innehåller din lokala dator, alla SSH-anslutningar i Anslutningshanteraren efter värdnamn och alla Windows-undersystem för Linux-installationer (WSL) som Visual Studio kan hitta:

Skärmbild av listrutan Målsystem

I föregående exempel:

  • 192.168.0.5 är ett linux-fjärrsystem som lades till i Anslutningshanteraren.
  • ubuntu2004 och debian är WSL-installationer.

Välj Hantera anslutningar för att öppna Anslutningshanteraren.

Välj en konfigurerad förinställning

Listrutan i mitten anger den aktiva Konfigurera förinställningen. Det är värdet configurePreset som används när CMake anropas för att generera projektets byggsystem. Den här listrutan innehåller en union av icke-dolda Konfigurera förinställningar som definierats i CMakePresets.json och CMakeUserPresets.json.

Visual Studio använder värdet hostOS i leverantörskartan för Microsoft Visual Studio-inställningar för att dölja Konfigurera förinställningar som inte gäller för det aktiva målsystemet. Mer information finns i posten för i tabellen under Leverantörskarta för hostOSVisual Studio-inställningar.

Välj Hantera konfigurationer för att öppna CMakePresets.json filen som finns i projektets rot. CMakePresets.json skapas om den inte redan finns.

Välj en byggförinställning

Listrutan till höger anger den aktiva build-förinställningen. Det är det buildPreset värde som används när CMake anropas för att skapa projektet. Den här listrutan innehåller en union av icke-dolda build-förinställningar som definierats i CMakePresets.json och CMakeUserPresets.json.

Alla build-förinställningar krävs för att ange ett associerat configurePreset värde. Visual Studio döljer build-förinställningar som inte gäller för den aktiva konfigurera förinställningen. Mer information finns i listan över build-förinställningar.

Om det inte finns några build-förinställningar som är associerade med den aktiva Konfigurera förinställningen visar Visual Studio standardversionens förinställning. Standardversionsförinställningen motsvarar att skicka cmake --build utan några andra argument från kommandoraden.

Konfigurera

Visual Studio försöker automatiskt konfigurera projektet när det upptäcker att CMake-cachen är inaktuell. Om du vill anropa konfigurationen manuellt väljer du Project>) på huvudmenyn.< Det är samma sak som att köra cmake --preset <configurePreset> från kommandoraden, där <configurePreset> är namnet på den aktiva konfigurera förinställningen.

Information om hur du inaktiverar automatisk cachegenerering finns i Automatiska konfigurations- och cachemeddelanden.

Skapa

Om du vill skapa hela projektet väljer du Skapa>alla på huvudmenyn. Det är samma sak som att köra cmake --build --preset <buildPreset> från kommandoraden, där <buildPreset> är namnet på den aktiva build-förinställningen.

Om du vill skapa ett enda mål växlar du till vyn CMake-mål i Solution Explorer. Högerklicka sedan på ett mål och välj Skapa på snabbmenyn.

Anmärkning

Visual Studio 2019 stöder buildPresets.targets inte alternativet att skapa en delmängd av målen som anges i CMakePresets.json.

Kör CTest

CMakePresets.json stöder två menyalternativ i Visual Studio 2019:

  • Test>Kör CTests för <projektnamn> anropar CTest och kör alla tester som är associerade med den aktiva konfigurera förinställningen och byggförinställningen, utan att några andra argument skickas till CTest.
  • Test>Kör testförinställning för <configurePreset> expanderas för att visa alla testförinställningar som är associerade med den aktiva konfigurera förinställningen. Att välja en enskild testförinställning är detsamma som att köra ctest --preset <testPreset> från kommandoraden, där <testPreset> är namnet på den valda testförinställningen. Det här alternativet är inte tillgängligt om inga testförinställningar har definierats för den aktiva konfigurera förinställningen.

I Visual Studio 2019 är Test Explorer inte integrerat med CMakePresets.json.

Lägga till nya förinställningar

I Visual Studio 2019 ändrar CMakePresets.jsonalla kommandon och förinställda mallar . Du kan lägga till nya förinställningar på användarnivå genom att redigera direkt CMakeUserPresets.json.

Använd ett snedstreck (/) för sökvägar i CMakePresets.json och CMakeUserPresets.json.

Lägg till nya konfigurera förinställningar

Om du vill lägga till en ny Konfigurera förinställning i CMakePresets.jsonfrån Solution Explorer högerklickar du CMakePresets.json från mappvyn och väljer Lägg till konfiguration på snabbmenyn. Dialogrutan för att välja en Konfigurera förinställd mall visas:

Skärmbild av dialogrutan Lägg till Konfigurera förinställning i JSON-filen. Den innehåller poster som Linux Debug, macOS Debug, x64 Debug och så vidare.

Välj den Windows x64-felsökningsmall som ska konfigureras på Windows-system. Välj den Linux-felsökningsmall som ska konfigureras på WSL- och fjärranslutna Linux-system. Mer information om redigering CMakePresets.jsonfinns i Redigera förinställningar.

Den valda mallen läggs till CMakePresets.json om den finns. Annars kopieras mallen till en ny CMakePresets.json fil.

Lägg till nya build-förinställningar och testförinställningar

Visual Studio 2019 erbjuder inte mallar för nya build-förinställningar och testförinställningar. Du kan lägga till Build Presets och Test Presets genom att direkt redigera CMakePresets.json. Mer information finns i listan över build-förinställningar, listan över testförinställningar eller en exempelfilCMakePresets.json.

Redigera förinställningar

Den officiella CMake-dokumentationen är den bästa resursen för redigering av Konfigurera förinställningar, Byggförinställningar och Testförinställningar. Följande information är en delmängd av CMake-dokumentationen som är särskilt relevant för Visual Studio-utvecklare.

Välj kompilatorer

Du kan ange C- och C++-kompilatorer med hjälp environment.CC av och environment.CXX i en Konfigurera förinställning. Mer information finns i CC/CXX.

Använd följande exempel för att skapa med cl.exe och clang-cl.exe från Visual Studio. C++ Clang-verktygen för Windows-komponenter måste installeras för att du ska kunna skapa med clang-cl.

Skapa med cl.exe:

"environment": {
  "CC": "cl",
  "CXX": "cl"
},
"cacheVariables": {
  "CMAKE_BUILD_TYPE": "Debug",
  "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}"
},

Skapa med clang:

"environment": {
  "CC": "clang-cl",
  "CXX": "clang-cl"
},
"cacheVariables": {
  "CMAKE_BUILD_TYPE": "Debug",
  "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}",
},

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

Om du använder antingen Visual Studio 16 2019 eller Visual Studio 17 2022 som generator kan du använda toolset Konfigurera förinställning för att ange verktygsuppsättningen ClangCL :

"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"
  }
}

Mer information om generatorer som stöder specifikationen toolsetCMAKE_GENERATOR_TOOLSET finns i CMake-dokumentationen.

Viktigt!

I Visual Studio 2019 måste du uttryckligen ange ett Clang IntelliSense-läge när du skapar med clang eller clang-cl.

Information om hur du återskapar dessa versioner utanför Visual Studio finns i Kör CMake från kommandoraden eller en CI-pipeline.

Om du vill bygga på Linux eller utan Microsoft C++ (MSVC) Build Tools anger du namnet på en kompilator på din PATH instans eller en miljövariabel som utvärderas till den fullständiga sökvägen för en kompilator. Fullständiga sökvägar rekommenderas inte så att filen kan delas. En förinställning som bygger med GCC version 8 kan se ut så här:

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

Du kan också ange kompilatorer med en CMake-verktygskedjafil. Verktygskedjans filer kan anges med cacheVariables.CMAKE_TOOLCHAIN_FILE, vilket motsvarar att skicka -D CMAKE_TOOLCHAIN_FILE=<value> till CMake från kommandoraden. En CMake-verktygskedjafil används oftast för korskompilering. Mer information om hur du redigerar CMake-verktygsringsfiler finns i CMake-verktygskedjor.

Välj generatorn

Windows- och Linux Configure Preset-mallarna anger båda Ninja som standardgenerator. Andra vanliga generatorer är Visual Studio Generators i Windows och Unix Makefiles i Linux och macOS. Du kan ange en ny generator med generator alternativet i en Konfigurera förinställning. Det motsvarar att skicka -G till CMake från kommandoraden.

Ange architecture.strategy och toolset.strategy till set när du skapar med en Visual Studio Generator. Mer information finns i CMake-generatorer.

Välj din konfigurationstyp

Du kan ange konfigurationstypen (Debug eller Release) för enskilda konfigurationsgeneratorer med hjälp cacheVariables.CMAKE_BUILD_TYPEav . Det motsvarar att skicka -D CMAKE_BUILD_TYPE=<value> till CMake från kommandoraden. Mer information finns i CMAKE_BUILD_TYPE.

Välj mål- och värdarkitektur när du skapar med Microsoft C++ Build Tools

Du kan ange målarkitekturen (x64, Win32, ARM64 eller ARM) med hjälp architecture.valueav . Det motsvarar att skicka -A till CMake från kommandoraden. Mer information finns i Plattformsval.

Anmärkning

Visual Studio Generators förväntar sig för närvarande Att Win32-syntaxen och kommandoradsgeneratorerna (som Ninja) förväntar sig x86-syntaxen när du skapar för x86.

Du kan ange värdarkitekturen (x64 eller x86) och verktygsuppsättningen med hjälp toolset.valueav . Det motsvarar att skicka -T till CMake från kommandoraden. Mer information finns i Val av verktygsuppsättning.

Värdena architecture.strategy och toolset.strategy talar om för CMake hur de ska hantera fälten arkitektur och verktygsuppsättning. set innebär att CMake anger respektive värde och external innebär att CMake inte anger respektive värde.

Vi rekommenderar att du använder set med IDE-generatorer som Visual Studio Generator. Använd external med kommandoradsgeneratorer som Ninja. Med dessa värden kan leverantörer som Visual Studio tillhandahålla den miljö som krävs innan CMake anropas. Mer information om fälten arkitektur och verktyg finns i listan med Konfigurera förinställningar.

Om du inte vill skapa en miljö kan du ange architecture.strategy till external och architecture.value till unspecified. Det kan vara bra att inte skapa en miljö av någon av följande skäl:

  • Du använder en annan verktygsuppsättning än MSVC.
  • Du använder en anpassad verktygskedja, till exempel i inbäddade scenarier.
  • Du behöver ingen specifik miljö för att skapa.

En fullständig lista över IDE-generatorer som stöder arkitekturfältet CMAKE_GENERATOR_PLATFORMfinns i . En fullständig lista över IDE-generatorer som stöder verktygsuppsättningsfältet CMAKE_GENERATOR_TOOLSETfinns i .

Använd följande exempel för att rikta ARM64 med Ninja-generatorn, eller för att rikta In Win32 (x86) med Visual Studio 16 2019-generatorn:

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

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

Ange och referera till miljövariabler

Du kan ange miljövariabler med hjälp av miljökartan. Miljövariabler ärvs via fältet inherits , men du kan åsidosätta dem som du vill.

En förinställnings miljö är en union av sin egen miljö och miljön från alla sina föräldrar. Om flera inherits förinställningar ger motstridiga värden för samma variabel föredras den tidigare förinställningen inherits i listan. Du kan ta bort en variabel som ärvts från en annan förinställning genom att ange den till null.

Miljövariabler som anges i en Konfigurera förinställning flödar också automatiskt igenom till associerade build-förinställningar och testförinställningar, såvida inte inheritConfigureEnvironment är inställt på false. Mer information finns i listan med Konfigurera förinställningar.

Du kan referera till miljövariabler med hjälp av syntaxen $env{<variable-name>} och $penv{<variable-name>} . Mer information finns i Makroexpansion.

Konfigurera IntelliSense för en korskompilator

Som standard använder Visual Studio IntelliSense-läget som matchar din angivna verktygsuppsättning och målarkitektur. Om du korskompilerar kan du behöva ange rätt IntelliSense-läge manuellt med hjälp intelliSenseMode av alternativet i leverantörskartan för Visual Studio-inställningar. Mer information finns i posten för i tabellen under Leverantörskarta för intelliSenseModeVisual Studio-inställningar.

Konfigurera och bygga på ett fjärrsystem eller Windows-undersystemet för Linux

Med CMakePresets.json stöd i Visual Studio kan du enkelt konfigurera och bygga projektet på Windows-, WSL- och fjärrsystem. Stegen för att konfigurera och bygga projektet i Windows, ett fjärrsystem eller WSL är desamma. Några beteenden är dock specifika för fjärrutveckling.

${sourceDir} beteende i fjärrkopieringsscenarier

I lokala scenarier (inklusive WSL1) ${sourceDir} utvärderas sökvägen till projektkällans katalog som är öppen i Visual Studio. I fjärrkopieringsscenarier ${sourceDir} utvärderas sökvägen till projektkällkatalogen i målsystemet och inte till projektkällkatalogen på den lokala datorn.

Värdet sourceDir för i leverantörskartan för Visual Studio-fjärrinställningar avgör projektkällkatalogen i målsystemet (standardvärdet är $env{HOME}/.vs/$ms{projectDirName}). Mer information finns i posten för i tabellen under Leverantörskarta för sourceDirVisual Studio-inställningar.

Lokal mapp för fjärrutdata

Fjärrkopieringsscenarier kräver en lokal katalog för att kopiera vissa fjärrfiler som CMake File API-svarsfiler eller byggfiler om copyBuildOutput leverantörskartan i Visual Studio Remote Settings är inställd på true. Dessa filer kopieras automatiskt till <local-source-directory>/out/<remote-connection-ID>/build/${presetName}.

Anropar samma konfigurerade förinställning i Windows och WSL1

Ett fel visas om du försöker använda samma Konfigurera förinställning i Windows och WSL1. Både Windows och WSL1 använder Windows-filsystemet, så CMake försöker använda samma utdatakatalog (binaryDir) för både Windows- och WSL1-byggträden.

Om du vill använda samma Konfigurera förinställning med både Windows och WSL1-verktygsuppsättningen skapar du en andra Konfigurera förinställning som ärver från den ursprungliga förinställningen och anger ett nytt binaryDir värde. I följande exempel windows-preset kan användas i Windows och base-preset kan användas på WSL1:

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

Anmärkning

I Visual Studio 2019 stöds endast WSL1-verktygsuppsättningen. Du ser det här beteendet varje gång du anropar configure på både Windows och WSL.

Aktivera vcpkg-integrering

Vcpkg hjälper dig att hantera C- och C++-bibliotek i Windows, Linux och macOS. En vcpkg-verktygskedjafil (vcpkg.cmake) måste skickas till CMake för att aktivera vcpkg-integrering. Mer information finns i dokumentationen om vcpkg.

Visual Studio skickar inte längre vcpkg-verktygskedjan till CMake automatiskt när CMakePresets.json integreringen är aktiverad. Den här ändringen eliminerar Visual Studio-specifikt beteende och säkerställer att du kan återskapa din version från kommandoraden.

Ange i stället sökvägen till vcpkg.cmake med hjälp VCPKG_ROOT av miljövariabeln i CMakePresets.json:

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

VCPKG_ROOT ska anges till roten för din vcpkg-installation. Mer information finns i miljövariabler för vcpkg.

Om du redan använder en CMake-verktygsringsfil och vill aktivera vcpkg-integrering kan du läsa Använda flera verktygsringsfiler. Följ dessa instruktioner om du vill använda en extern verktygskedja med ett projekt med hjälp av vcpkg.

Variabel ersättning i launch.vs.json och tasks.vs.json

CMakePresets.json stöder variabel ersättning i launch.vs.json och tasks.vs.json. Här följer några överväganden:

  • Miljövariabler som anges i den aktiva Konfigurera förinställningen flödar automatiskt till launch.vs.json och tasks.vs.json konfigurationer. Du kan ta bort enskilda miljövariabler i launch.vs.json och tasks.vs.json genom att ange dem till null. I följande exempel anges variabeln DEBUG_LOGGING_LEVEL till null i launch.vs.json: "env": { "DEBUG_LOGGING_LEVEL": null }.

  • Nyckelvärden som anges i den aktiva Konfigurera förinställningen är tillgängliga för förbrukning i launch.vs.json och tasks.vs.json med syntaxen ${cmake.<KEY-NAME>}. Använd till exempel ${cmake.binaryDir} för att referera till utdatakatalogen för den aktiva konfigurera förinställningen.

  • Enskilda miljövariabler som anges i miljökartan för den aktiva Konfigurera förinställningen är tillgängliga för förbrukning i launch.vs.json och tasks.vs.json via syntaxen ${env.<VARIABLE-NAME>}.

Uppdatera dina launch.vs.json filer och task.vs.json till referenssyntax CMakePresets.json i stället CMakeSettings.json för syntax. Makron som refererar till den gamla CMakeSettings.json syntaxen när CMakePresets.json är den aktiva konfigurationsfilen planeras för utfasning i en framtida version. Du kan till exempel referera till utdatakatalogen för den aktiva konfigurera förinställningen med ${cmake.binaryDir} i stället för ${cmake.buildRoot}, eftersom CMakePresets.json syntaxen binaryDir används.

Felsökning

Om det inte fungerar som förväntat kan du prova några felsökningssteg.

Om antingen CMakePresets.json eller CMakeUserPresets.json är ogiltigt återgår Visual Studio till standardbeteendet och visar endast standardinställningen Konfigurera förinställningar. Visual Studio IntelliSense kan hjälpa dig att fånga upp många av dessa JSON-fel, men det vet inte om du refererar till en förinställning med eller inherits med configurePreset fel namn.

Kontrollera om dina förinställda filer är giltiga genom att köra cmake --list-presets från kommandoraden i roten i projektkatalogen. (CMake 3.20 eller senare krävs.) Om någon av filerna är ogiltiga visas följande fel:

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

Andra felsökningssteg är:

  • Ta bort cacheminnet och konfigurera om projektet (CMake: Ta bort cacheminne och Project>Configure <project-name>).
  • Stäng och öppna mappen igen i Visual Studio (arkivstängningsmapp>).
  • .vs Ta bort mappen i roten i projektet.

Om du har identifierat ett problem är det bästa sättet att rapportera det genom att välja knappen Skicka feedback i det övre högra hörnet i Visual Studio.

Aktivera loggning för fjärranslutningar

Du kan aktivera loggning för fjärranslutningar om du har problem med att ansluta eller kopiera filer till ett fjärrsystem. Mer information finns i Loggning för fjärranslutningar.

Aktivera AddressSanitizer för Windows och Linux

Visual Studio stöder AddressSanitizer (ASAN), en C- och C++-körningsminnesfelidentifiering, för både Windows- och Linux-utveckling. Alternativet addressSanitizerEnabled i CMakeSettings.json aktiverar AddressSanitizer. CMakePresets.json stöder inte det här beteendet.

Aktivera och inaktivera i stället AddressSanitizer genom att ange nödvändiga kompilator- och länkflaggor själv. Om du ställer in dem tar du bort Visual Studio-specifikt beteende och ser till att samma CMakePresets.json fil kan återskapa din version från kommandoraden.

Du kan lägga till följande exempel för att CMakeLists.txt aktivera eller inaktivera AddressSanitizer för ett mål:

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()

I <additional-options> delen visas andra kompileringsflaggor, till exempel "-fno-omit-frame-pointer". Mer information om AddressSanitizer för Linux finns i Använda AddressSanitizer. Mer information om hur du använder AddressSanitizer med MSVC finns i Använda AddressSanitizer från en kommandotolk för utvecklare.

Skicka körningsflaggor till AddressSanitizer med hjälp av fältet ASAN_OPTIONS i launch.vs.json. ASAN_OPTIONS standardvärdet är detect_leaks=0 när inga andra körningsalternativ har angetts eftersom LeakSanitizer inte stöds i Visual Studio.

Kör CMake från kommandoraden eller en CI-pipeline

Du kan använda samma CMakePresets.json filer och CMakeUserPresets.json för att anropa CMake i Visual Studio och från kommandoraden. CMake- och CTest-dokumentationen är de bästa resurserna för att anropa CMake och CTest med --preset. CMake version 3.20 eller senare krävs.

Köpa miljön när du skapar med kommandoradsgeneratorer i Windows

Det är upp till användaren att konfigurera miljön innan CMake anropas i byggnaden med en kommandoradsgenerator. Om du skapar med Ninja och Microsoft C++ Build Tools i Windows anger du miljön innan CMake anropas för att generera byggsystemet. Du kan göra det genom att anropa vcvarsall.bat med architecture argumentet . Argumentet architecture anger vilken värd- och målarkitektur som ska användas. Mer information finns i vcvarsall syntax. Om du bygger på Linux eller Windows med en Visual Studio Generator behöver du inte ta det här steget.

Det är samma steg som Visual Studio tar åt dig när IDE anropar CMake. Visual Studio parsar den aktiva Konfigurera förinställning för värd- och målarkitekturen som anges av toolset och architecture. Visual Studio hämtar sedan den angivna miljön från vcvarsall.bat. När du skapar från Windows-kommandoraden med Ninja måste du ta det här steget själv.

vcvarsall.bat installeras med Build Tools för Visual Studio. Installeras som standard vcvarsall.bat i C:\Program Files (x86)\Microsoft Visual Studio\2019\<edition>\VC\Auxiliary\Build. Du kan lägga till vcvarsall.batPATH i om du använder kommandoradsarbetsflödet ofta.

Exempel på kommandoradsarbetsflöde

Du kan använda följande kommandon för att konfigurera och skapa ett CMake-projekt som använder Ninja för att rikta in sig på ARM64 med x64-byggverktyg. CMake version 3.20 eller senare krävs. Kör dessa kommandon från katalogen där CMakePresets.json filen finns:

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

Exempelfil CMakePresets.json

Filen CMakePresets.json i box2d-lite innehåller exempel på Konfigurera förinställningar, Skapa förinställningar och Testförinställningar. Mer information om det här exemplet finns i presentationen En introduktion till CMakePresets.json. Du kan se ett annat exempel i DirectXTK-projektet , som visar många byggmål i avsnittet configurePresets .

Nästa steg

Läs mer om att konfigurera och felsöka CMake-projekt i Visual Studio:

CMake-projekt i Visual Studio
Anpassa CMake-bygginställningar
Konfigurera CMake-felsökningssessioner
fördefinierade konfigurationsreferens för CMake

  • Last updated on