CMake-projecten in Visual Studio

Met de systeemeigen ondersteuning van Visual Studio voor CMake kunt u CMake-projecten bewerken, bouwen en fouten opsporen in Windows, het Windows-subsysteem voor Linux (WSL) en externe systemen van hetzelfde exemplaar van Visual Studio. CMake-projectbestanden (zoals CMakeLists.txt) worden rechtstreeks door Visual Studio gebruikt voor intelliSense en browsen. cmake.exe wordt rechtstreeks aangeroepen door de configuratie en build van Visual Studio for CMake.

Installatie

C++ CMake-hulpprogramma's voor Windows wordt geïnstalleerd als onderdeel van de Desktop-ontwikkeling met C++ en Linux-ontwikkeling met C++-workloads. Zowel CMake-hulpprogramma's voor Windows als Linux Development met C++ zijn vereist voor platformoverschrijdende CMake-ontwikkeling.

Zie De C++ Linux-workload installeren in Visual Studiovoor meer informatie.

IDE-integratie

Wanneer u een map met een CMakeLists.txt-bestand opent, gebeurt het volgende.

• Visual Studio voegt CMake--items toe aan het menu Project, met opdrachten voor het weergeven en bewerken van CMake-scripts.

• In de Solution Explorer worden de mappenstructuur en bestanden weergegeven.

• Visual Studio voert CMake uit en genereert het CMake-cachebestand (CMakeCache.txt) voor de standaardconfiguratie. De CMake-opdrachtregel wordt weergegeven in het Uitvoervenster, samen met andere uitvoer van CMake.

• Op de achtergrond begint Visual Studio de bronbestanden te indexeren om IntelliSense, browse-informatie, herstructurering, enzovoort in te schakelen. Terwijl u werkt, bewaakt Visual Studio wijzigingen in de editor en ook op schijf om de index gesynchroniseerd te houden met de bronnen.

Zodra het genereren van de CMake-cache is geslaagd, kunt u uw projecten ook logisch op doelen ordenen. Kies de knop Selecteren van weergave op de werkbalk Solution Explorer. Selecteer in de lijst in Solution Explorer - Weergavende CMake Targets View en druk op Enter om de doelweergave te openen:

Kies de knop Alle bestanden weergeven bovenaan Solution Explorer- om alle door CMake gegenereerde uitvoer in de out/build/<config> mappen weer te geven.

Gebruik het CMakeLists.txt-bestand in elke projectmap, net zoals in elk CMake-project. U kunt bronbestanden opgeven, bibliotheken zoeken, compiler- en linkeropties instellen en andere informatie over het buildsysteem opgeven. Zie voor meer informatie over de CMake-taaldiensten die door Visual Studio worden geleverd, de sectie Bewerken van CMakeLists.txt bestanden.

Visual Studio maakt gebruik van een CMake-configuratiebestand voor het genereren en bouwen van CMake-cache. Zie CMake-projecten configureren en CMake-projecten configurerenvoor meer informatie.

Als u argumenten tijdens foutopsporing wilt doorgeven aan een uitvoerbaar bestand, kunt u een ander bestand gebruiken met de naam launch.vs.json. Zie CMake-projecten voor foutopsporingvoor meer informatie over het opsporen van fouten in platformoverschrijdende CMake-projecten in Visual Studio.

De meeste visual studio- en C++-taalfuncties worden ondersteund door CMake-projecten in Visual Studio. Voorbeelden zijn:

• bewerken en doorgaan voor CMake-projecten
• Incredibuild-integratie voor CMake-projecten
• AddressSanitizer-ondersteuning voor CMake-projecten
• Clang/LLVM-ondersteuning

CMake-projecten configureren

Met de CMake-configuratiestap wordt het projectbuildsysteem gegenereerd. Het is gelijk aan het aanroepen van cmake.exe vanaf de opdrachtregel. Zie de CMake-documentatievoor meer informatie over de CMake-configuratiestap.

Visual Studio maakt gebruik van een CMake-configuratiebestand voor het genereren en bouwen van CMake. CMakePresets.json wordt ondersteund door Visual Studio 2019 versie 16.10 of hoger en is het aanbevolen CMake-configuratiebestand. CMakePresets.json wordt rechtstreeks ondersteund door CMake en kan worden gebruikt om CMake-generatie en -build te sturen vanuit Visual Studio, vanuit VS Code, in een pijplijn voor continue integratie en vanaf de opdrachtregel op Windows, Linux en Mac. Zie Configureren en bouwen met CMake Presetsvoor meer informatie over CMakePresets.json. CMakeSettings.json is beschikbaar voor klanten die een eerdere versie van Visual Studio gebruiken. Zie CMake-buildinstellingen aanpassenvoor meer informatie over CMakeSettings.json.

Wanneer u belangrijke wijzigingen aanbrengt in uw CMake-configuratiebestand of een CMakeLists.txt-bestand, voert Visual Studio automatisch de CMake-configuratiestap uit. U kunt de configuratiestap handmatig aanroepen: selecteer Project > Cache configureren op de werkbalk. U kunt uw configuratievoorkeuren ook wijzigen in Tools>Options>CMake>General.

Als de configuratiestap zonder fouten is voltooid, is de beschikbare informatie bepalend voor C++ IntelliSense en taalservices. Het wordt ook gebruikt in build- en foutopsporingsbewerkingen.

U kunt ook een bestaande CMake-cache openen in Visual Studio. Zie Een bestaande cache openenvoor meer informatie.

Feedback en meldingen van configuratie aanpassen

Standaard worden de meeste configuratieberichten onderdrukt, tenzij er een fout optreedt. Om alle berichten te zien, selecteert u Tools>Options>CMake>diagnostische uitvoer van CMake inschakelen.

U kunt ook alle CMake-cachemeldingen (gouden balken) uitschakelen door Melding van CMake-cache weergevenuit te schakelen.

Doelweergavebrongroepen aanpassen

Standaard negeert de weergave CMake-doelen de volgende brongroepen: 'Bronbestanden', 'HeaderBestanden', 'Resources', 'Objectbestanden'. Dit komt doordat ze standaard zijn opgenomen in de meeste CMake-projecten en het aantal klikken dat nodig is om door de doelenweergave te navigeren, onnodig zou verhogen.

Schakel het gebruik van deze brongroepen in door Tools>Opties>CMake>Schakel het gebruik van genegeerde brongroepen in in CMake-doelweergavein te schakelen.

Problemen met CMake-cache oplossen

Als u meer informatie nodig hebt over de status van de CMake-cache om een probleem vast te stellen, opent u het hoofdmenu van Project of het contextmenu van CMakeLists.txt in Solution Explorer om een van deze opdrachten uit te voeren:

• View CMakeCache.txt opent het CMakeCache.txt bestand vanuit de buildmap in de editor. Alle wijzigingen die u hier aanbrengt aan CMakeCache.txt worden verwijderd als u de cache leegt. Als u wijzigingen wilt aanbrengen die behouden blijven nadat u de cache hebt opgeschoond, raadpleegt u CMake-instellingen aanpassen of Configureren en bouwen met CMake Presets.

• Cache verwijderen en opnieuw configureren verwijdert de buildmap en configureert opnieuw vanuit een schone cache.

• Cache configureren zorgt ervoor dat de stap 'genereren' wordt uitgevoerd, zelfs als Visual Studio de omgeving als up-to-date beschouwt.

CMake-projecten bouwen

De CMake-buildstap bouwt een al gegenereerde binaire projectstructuur. Het is gelijk aan het aanroepen van cmake --build vanaf de opdrachtregel. Zie de CMake-documentatievoor meer informatie over de CMake-buildstap.

Als u een CMake-project wilt bouwen, hebt u de volgende opties:

1. Zoek in de werkbalk de opstartitem vervolgkeuzelijst. Selecteer het voorkeursdoel en druk op F5of kies de knop uitvoeren op de werkbalk. Het project bouwt automatisch eerst, net als een Visual Studio-oplossing.

2. Klik met de rechtermuisknop op het CMake-doel met CMake Targets View actief in de Solution Explorer- en selecteer Build in het contextmenu.

3. Kies in het hoofdmenu Build > Build All. Zorg ervoor dat er al een CMake-doel is geselecteerd in de dropdown Opstartitem in de werkbalk.

Zoals u zou verwachten, worden build-resultaten weergegeven in het Uitvoervenster en de Foutenlijst.

Waarschuwingen in CMake over conversies die kunnen leiden tot gegevensverlies, zoals het omzetten van een float naar een geheel getal, zijn zichtbaar. :::image-end:::

Build-instellingen bewerken

Visual Studio maakt gebruik van een CMake configuratiebestand om CMake-builds aan te sturen. CMake-configuratiebestand bevat buildopties zoals schakelaars van systeemeigen build-tools en omgevingsvariabelen. Als CMakePresets.json uw actieve configuratiebestand is, raadpleegt u Configureren en bouwen met CMake Presets. Als CMakeSettings.json uw actieve configuratiebestand is, raadpleegt u CMake-buildinstellingen aanpassen. CMakePresets.json is beschikbaar in Visual Studio 2019 versie 16.10 of hoger en is het aanbevolen CMake-configuratiebestand.

Fouten opsporen in CMake-projecten

Alle uitvoerbare CMake-doelen worden weergegeven in de opstartitem vervolgkeuzelijst op de werkbalk. Als u foutopsporing wilt starten, selecteert u er een en drukt u op de Foutopsporing > knop Foutopsporing starten op de werkbalk. In een CMake-project is de optie Huidig document alleen geldig voor .cpp bestanden.

De opdrachten Debug of F5 bouwen eerst het project als er wijzigingen zijn aangebracht sinds de vorige build. Wijzigingen in het CMake-configuratiebestand (CMakePresets.json of CMakeSettings.json) of CMakeLists.txt zorgt ervoor dat de CMake-cache opnieuw wordt gegenereerd.

U kunt een CMake-foutopsporingssessie aanpassen door eigenschappen in te stellen in het bestand launch.vs.json. Als u de debuginstellingen voor een specifiek target wilt aanpassen, selecteert u het target in de vervolgkeuzelijst Opstartitem en drukt u op Debuggen > Debuggen en startinstellingen voor <actieve target>. Zie CMake-foutopsporingssessies configurerenvoor meer informatie over CMake-foutopsporingssessies.

Just My Code voor CMake-projecten

Wanneer u voor Windows bouwt met behulp van de MSVC-compiler, bieden CMake-projecten ondersteuning voor Just My Code-foutopsporing. Als u de instelling Just My Code wilt wijzigen, gaat u naar Extra>Opties>Foutopsporing>Algemene. Zie Alleen gebruikerscode opsporen met Just My Codevoor meer informatie over Just My Code-foutopsporing.

Bewerken en doorgaan voor CMake-projecten

Wanneer u voor Windows bouwt met de MSVC-compiler, hebben CMake-projecten ondersteuning voor Bewerken en Doorgaan. Voeg de volgende code toe aan uw CMakeLists.txt-bestand om Bewerken en Doorgaan in te schakelen. Zie Bewerken en Doorgaan configureren (C#, VB, C++)voor meer informatie over Bewerken en Doorgaan.

if(MSVC)
  target_compile_options(<target> PUBLIC "/ZI")
  target_link_options(<target> PUBLIC "/INCREMENTAL")
endif()

Koppelen aan een CMake-project dat wordt uitgevoerd op Linux

Met Visual Studio kunt u fouten opsporen in een proces dat wordt uitgevoerd op een extern Linux-systeem of WSL en fouten opsporen met het GDB-foutopsporingsprogramma. Als u wilt beginnen, selecteert u Foutopsporing>Koppelen aan proces..., stelt u het verbindingstype in op SSH-en selecteert u het verbindingsdoel in de lijst met verbindingen in Verbindingsbeheer. Selecteer een proces uit de lijst met beschikbare processen en druk op Bijvoegen. GDB moet zijn geïnstalleerd op uw Linux-computer. Zie de Verbindingsbeheer- voor meer informatie over SSH-verbindingen

Gedeeltelijke activering van CMake

In Visual Studio 2022 versie 17.1 en hoger wordt de CMake-functionaliteit niet automatisch ingeschakeld als uw hoofdmap geen CMakeLists.txt bestand bevat. In plaats daarvan wordt u in een dialoogvenster gevraagd of u de CMake-functionaliteit voor uw project wilt inschakelen. Als u dit weigert, wordt het genereren van de CMake-cache niet gestart en worden CMake-configuraties (van CMakeSettings.json of CMakePresets.json) niet weergegeven in de vervolgkeuzelijst configuratie. Als u akkoord gaat, gaat u naar een configuratiebestand op werkruimteniveau, CMakeWorkspaceSettings.json (opgeslagen in de map .vs), om de mappen op te geven waarvoor u CMake wilt inschakelen. (Deze mappen bevatten uw hoofdbestanden CMakeLists.txt).

De geaccepteerde eigenschappen zijn:

U kunt CMakeWorkspaceSettings.json bereiken via de opdracht Project>CMake Workspace Settings menu, zelfs als CMake-functionaliteit momenteel is uitgeschakeld.

Een bestaande cache openen

Wanneer u een bestaand CMake-cachebestand (CMakeCache.txt) opent, probeert Visual Studio uw cache niet te beheren en een structuur voor u te bouwen. Uw aangepaste of voorkeurshulpprogramma's hebben volledige controle over hoe CMake uw project configureert.

U kunt een bestaande CMake-cache toevoegen aan een geopend project. Dit doet u op dezelfde manier als u een nieuwe configuratie toevoegt. Zie onze blogpost over het openen van een bestaande cache in Visual Studiovoor meer informatie.

Geavanceerde probleemoplossing van CMake-cache

Visual Studio maakt gebruik van de op bestanden gebaseerde API CMake (in versie 3.14 en hoger) om de editor te vullen met informatie die specifiek is voor uw projectstructuur. Zie het blogbericht van het C++-team over werkruimten met meerdere hoofdmappen en op bestanden gebaseerde API-voor meer informatie.

Voordat u de CMake-cache genereert, moeten uw aangepaste of voorkeurshulpprogramma's mogelijk een querybestand maken met de naam .cmake/api/v1/query/client-MicrosoftVS/query.json in de build-uitvoermap (de map die CMakeCache.txtbevat). Het querybestand moet deze inhoud bevatten:

{"requests":[{"kind":"cache","version":2},{"kind":"cmakeFiles","version":1},{"kind":"codemodel","version":2}]}

Wanneer uw aangepaste of voorkeurshulpprogramma's uw cache genereren, plaatst CMake bestanden onder .cmake/api/v1/response die Visual Studio gebruikt om de editor te vullen met informatie die specifiek is voor uw projectstructuur.

CMakeLists.txt-bestanden bewerken

Als u een CMakeLists.txt-bestand wilt bewerken, klikt u met de rechtermuisknop op het bestand in Solution Explorer- en kiest u openen. Als u wijzigingen aanbrengt in het bestand, wordt er een gele statusbalk weergegeven en wordt u geïnformeerd dat IntelliSense wordt bijgewerkt. Hiermee kunt u de updatebewerking annuleren. Zie de CMake-documentatievoor meer informatie over CMakeLists.txt.

Zodra u het bestand opslaat, wordt de configuratiestap automatisch opnieuw uitgevoerd en wordt informatie weergegeven in het venster Uitvoer. Fouten en waarschuwingen worden weergegeven in het venster Foutenlijst of Uitvoer. Dubbelklik op een fout in de Foutenlijst om naar de overtredende regel in CMakeLists.txtte gaan.

Taalservices voor CMake

Taalservices voor CMake zijn beschikbaar in Visual Studio 2019 versie 16.5 of hoger. Het biedt ondersteuning voor codenavigatiefuncties zoals Go To Definition, Peek Definition en Find All References voor CMake-variabelen, functies en doelen in CMake-scriptbestanden. Zie Codenavigatie voor CMake Scriptsvoor meer informatie.

CMake projectmanipulatie

CMake-projectmanipulatie is beschikbaar in Visual Studio 2019 versie 16.5 of hoger. Met projectmanipulatie kunt u bronbestanden en -doelen toevoegen, verwijderen en hernoemen in uw CMake-project zonder dat u uw CMake-scripts handmatig hoeft te bewerken. Wanneer u bestanden toevoegt aan of verwijdert uit Solution Explorer, wordt uw CMake-project automatisch bewerkt in Visual Studio. Er kan meer dan één plaats zijn waar het zinvol is om een verwijzing naar een CMake-script toe te voegen of te verwijderen. Zo ja, dan vraagt Visual Studio u waar u de wijziging wilt aanbrengen en geeft een voorbeeld weer van de voorgestelde wijzigingen. Zie Bestanden en doelen toevoegen, verwijderen en hernoemen in CMake Projectsvoor stapsgewijze instructies.

IntelliSense voor CMake-projecten

Visual Studio maakt standaard gebruik van de IntelliSense-modus die overeenkomt met de compiler- en doelarchitectuur die is opgegeven door de actieve CMake-configuratie.

Als CMakePresets.json uw actieve CMake-configuratiebestand is, kunt u IntelliSense-opties opgeven met behulp van intelliSenseMode en intelliSenseOptions in de leverancierskaart van Visual Studio-instellingen. Zie voor meer informatie de leverancierskaartreferentie voor Visual Studio-instellingen .

Als CMakeSettings.json uw actieve CMake-configuratiebestand is, kunt u IntelliSense-opties opgeven met behulp van intelliSenseMode in CMakeSettings.json. Zie de CMakeSettings.json-verwijzingvoor meer informatie.

Configureer IntelliSense met CMake-toolchainbestanden.

In Visual Studio 2019 versie 16.9 en hoger configureert Visual Studio automatisch IntelliSense in CMake-projecten op basis van CMake-variabelen wanneer u een CMake-hulpprogrammaketenbestand gebruikt. Zie IntelliSense configureren met CMake Toolchain Filesvoor meer informatie.

Vcpkg-integratie

CMake-projecten die zijn geopend in Visual Studio integreren met vcpkg, een platformoverschrijdend C/C++-afhankelijkheidsmanager. Voordat u vcpkg met Visual Studio gebruikt, moet u vcpkg integrate installuitvoeren. Zie voor instructies en meer informatie over vcpkg:

• Pakketten installeren en gebruiken met CMake in Visual Studio
• vcpkg in CMake-projecten

Als CMakeSettings.json uw actieve configuratiebestand is, geeft Visual Studio het vcpkg-hulpprogrammaketenbestand (vcpkg.cmake) automatisch door aan CMake. Dit gedrag wordt automatisch uitgeschakeld wanneer u een andere hulpprogrammaketen opgeeft in de configuratie van uw CMake-instellingen.

Als CMakePresets.json uw actieve configuratiebestand is, moet u het pad instellen op vcpkg.cmake in CMakePresets.json. U wordt aangeraden de omgevingsvariabele VCPKG_ROOT te gebruiken in plaats van een absoluut pad om het bestand deelbaar te houden. Zie Vcpkg-integratie inschakelen met CMake Presetsvoor meer informatie. CMakePresets.json is beschikbaar in Visual Studio 2019 versie 16.10 of hoger en is het aanbevolen CMake-configuratiebestand.

CMake uitvoeren vanaf de opdrachtregel

Als CMakePresets.json uw actieve CMake-configuratiebestand is, kunt u uw lokale builds eenvoudig buiten Visual Studio reproduceren. Zie CMake uitvoeren vanaf de opdrachtregel of een CI-pijplijnvoor meer informatie. CMakePresets.json wordt ondersteund in Visual Studio 2019 versie 16.10 of hoger en is het aanbevolen CMake-configuratiebestand.

Als CMakeSettings.json het actieve CMake-configuratiebestand is, moet u de argumenten die zijn gecodeerd in uw CMakeSettings.json-bestand handmatig doorgeven aan CMake. Als u CMake hebt geïnstalleerd vanuit het Installatieprogramma van Visual Studio, kunt u deze uitvoeren vanaf de opdrachtregel door de volgende stappen uit te voeren:

1. Voer het juiste vsdevcmd.bat-bestand (x86/x64) uit. Zie Bouwen op de opdrachtregel voor meer informatie.

2. Schakel over naar de uitvoermap.

3. Voer CMake uit om uw app te bouwen of te configureren.

Visual Studio 2017 biedt uitgebreide ondersteuning voor CMake, waaronder platformoverschrijdende CMake-projecten. Het onderdeel Visual C++ Tools for CMake maakt gebruik van de functie Map openen zodat de IDE CMake-projectbestanden (zoals CMakeLists.txt) rechtstreeks kan gebruiken voor IntelliSense en browsen. Zowel Ninja- als Visual Studio-generatoren worden ondersteund. Als u een Visual Studio-generator gebruikt, wordt er een tijdelijk projectbestand gegenereerd en doorgegeven aan MSBuild. Het project wordt echter nooit geladen voor IntelliSense of browsedoeleinden. U kunt ook een bestaande CMake-cache importeren.

Installatie

Visual C++ Tools for CMake is geïnstalleerd als onderdeel van de ontwikkeling van Desktop met C++ en Linux Development met C++ workloads.

Zie De C++ Linux-workload installeren in Visual Studiovoor meer informatie.

IDE-integratie

Wanneer u Bestand >> map openen kiest om een map met een CMakeLists.txt bestand te openen, gebeurt het volgende:

• Visual Studio voegt een menu-item CMake toe aan het hoofdmenu, met opdrachten voor het weergeven en bewerken van CMake-scripts.

• Solution Explorer de mapstructuur en bestanden weergeeft.

• Visual Studio voert CMake uit en genereert desgewenst de CMake-cache voor de standaardconfiguratie , x86 Debug. De CMake-opdrachtregel wordt weergegeven in het Uitvoervenster, samen met andere uitvoer van CMake.

• Op de achtergrond begint Visual Studio de bronbestanden te indexeren om IntelliSense, browse-informatie, herstructurering, enzovoort in te schakelen. Terwijl u werkt, bewaakt Visual Studio wijzigingen in de editor en ook op schijf om de index gesynchroniseerd te houden met de bronnen.

U kunt mappen met een willekeurig aantal CMake-projecten openen. Visual Studio detecteert en configureert alle 'root'-CMakeLists.txt bestanden in uw werkruimte. CMake-bewerkingen (configureren, bouwen, fouten opsporen), C++ IntelliSense en bladeren zijn beschikbaar voor alle CMake-projecten in uw werkruimte.

U kunt uw projecten ook logisch op doelen ordenen. Kies de Targets-weergave in de vervolgkeuzelijst op de Solution Explorer werkbalk:

Visual Studio maakt gebruik van een bestand met de naam CMakeSettings.json voor het opslaan van omgevingsvariabelen of opdrachtregelopties voor CMake. CMakeSettings.json kunt u ook meerdere CMake-buildconfiguraties definiëren en opslaan. U kunt er gemakkelijk tussen schakelen in de IDE.

Gebruik anders de CMakeLists.txt net zoals in elk CMake-project om bronbestanden op te geven, bibliotheken te zoeken, compiler- en linkeropties in te stellen en andere informatie over het buildsysteem op te geven.

Als u argumenten tijdens foutopsporing aan een uitvoerbaar bestand moet doorgeven, kunt u een ander bestand met de naam launch.vs.jsongebruiken. In sommige scenario's genereert Visual Studio deze bestanden automatisch. U kunt ze handmatig bewerken of zelfs zelf het bestand maken.

Een bestaande cache importeren

Wanneer u een bestaand CMakeCache.txt-bestand importeert, extraheert Visual Studio automatisch aangepaste variabelen en maakt u een vooraf ingevuld CMakeSettings.json bestand op basis hiervan. De oorspronkelijke cache wordt op geen enkele manier gewijzigd. Het kan nog steeds worden gebruikt vanaf de opdrachtregel, of met elk hulpprogramma of IDE dat is gebruikt om het te genereren. Het nieuwe CMakeSettings.json-bestand wordt naast de hoofdmap van het project geplaatst CMakeLists.txt. Visual Studio genereert een nieuwe cache op basis van het instellingenbestand. U kunt het automatisch genereren van caches overschrijven in het dialoogvenster Hulpmiddelen > Opties > CMake > Algemeen.

Niet alles in de cache wordt geïmporteerd. Eigenschappen zoals de generator en de locatie van de compilers worden vervangen door standaardwaarden die bekend zijn om goed te werken met de IDE.

Een bestaande cache importeren

1. Kies in het hoofdmenu Bestand > Openen > CMake:

   

   Met deze opdracht wordt de wizard CMake importeren uit cache weergegeven.

2. Navigeer naar het CMakeCache.txt-bestand dat u wilt importeren en kies vervolgens OK-. De wizard voor het importeren van het CMake-project uit de cache verschijnt.

   

   Wanneer de wizard is voltooid, ziet u het nieuwe CMakeCache.txt-bestand in Solution Explorer naast het hoofdbestand CMakeLists.txt in uw project.

CMake-projecten bouwen

Als u een CMake-project wilt bouwen, hebt u de volgende opties:

1. Zoek in de werkbalk Algemeen de vervolgkeuzelijst Configuraties. Standaard wordt 'Linux-Debug' of 'x64-Debug' weergegeven. Selecteer de voorkeursconfiguratie en druk op F5-of kies de knop uitvoeren (groene driehoek) op de werkbalk. Het project bouwt automatisch eerst, net als een Visual Studio-oplossing.

2. Klik met de rechtermuisknop op CMakeLists.txt in Solution Explorer- en selecteer Build in het contextmenu. Als u meerdere doelen in uw mapstructuur hebt, kunt u ervoor kiezen om alle of slechts één specifiek doel te maken.

3. In het hoofdmenu, selecteer Build > Build Solution (F7 of Ctrl+Shift+B). Zorg ervoor dat er al een CMake-target is geselecteerd in de opstartitem-keuzelijst , in de werkbalk Algemeen.

U kunt buildconfiguraties, omgevingsvariabelen, opdrachtregelargumenten en andere instellingen in het CMakeSettings.json-bestand aanpassen. Hiermee kunt u wijzigingen aanbrengen zonder het CMakeLists.txt-bestand te wijzigen. Zie CMake-instellingen aanpassenvoor meer informatie.

Zoals u zou verwachten, worden buildresultaten weergegeven in het Uitvoervenster en Foutenlijst.

In een map met meerdere builddoelen kunt u opgeven welk CMake-doel u wilt bouwen: Kies het item Build in het menu CMake of het contextmenu CMakeLists.txt om het doel op te geven. Als u Ctrl+Shift+B- invoert in een CMake-project, wordt het huidige actieve document gebouwd.

Fouten opsporen in CMake-projecten

Als u fouten wilt opsporen in een CMake-project, kiest u de voorkeursconfiguratie en drukt u op F5. Of druk op de knop uitvoeren op de werkbalk. Als op de knop Uitvoeren 'Opstartitem selecteren' staat, selecteer dan de vervolgkeuzepijl en kies het doelwit dat u wilt uitvoeren. (In een CMake-project is de optie Huidig document alleen geldig voor .cpp bestanden.)

selecteren

De Run- of F5-commando's bouwen eerst het project als er wijzigingen zijn aangebracht sinds de vorige build.

U kunt een CMake-foutopsporingssessie aanpassen door eigenschappen in te stellen in het bestand launch.vs.json. Zie CMake-foutopsporingssessies configurerenvoor meer informatie.

CMakeLists.txt-bestanden bewerken

Als u een CMakeLists.txt-bestand wilt bewerken, klikt u met de rechtermuisknop op het bestand in Solution Explorer- en kiest u openen. Als u wijzigingen aanbrengt in het bestand, wordt er een gele statusbalk weergegeven en wordt u geïnformeerd dat IntelliSense wordt bijgewerkt. Hiermee kunt u de updatebewerking annuleren. Zie de CMake-documentatievoor meer informatie over CMakeLists.txt.

Zodra u het bestand opslaat, wordt de configuratiestap automatisch opnieuw uitgevoerd en wordt informatie weergegeven in het venster Uitvoer. Fouten en waarschuwingen worden weergegeven in het venster Foutenlijst of Uitvoer. Dubbelklik op een foutmelding in de foutenlijst om naar de betreffende regel in CMakeLists.txtte gaan.

CMake configuratiestap

Wanneer er belangrijke wijzigingen worden aangebracht in de CMakeSettings.json of in CMakeLists.txt bestanden, voert Visual Studio de CMake-configuratiestap automatisch opnieuw uit. Als de configuratiestap zonder fouten is voltooid, is de verzamelde informatie beschikbaar in C++ IntelliSense en taalservices. Het wordt ook gebruikt in build- en foutopsporingsbewerkingen.

Meerdere CMake-projecten kunnen dezelfde CMake-configuratienaam gebruiken (bijvoorbeeld x86-Debug). Ze zijn allemaal geconfigureerd en gebouwd (in hun eigen build-rootmap) wanneer die configuratie wordt geselecteerd. U kunt de targets van alle CMake-projecten die deelnemen aan die CMake-configuratie debuggen.

U kunt builds en foutopsporingssessies beperken tot een subset van de projecten in de werkruimte. Maak een nieuwe configuratie met een unieke naam in het CMakeSettings.json-bestand. Pas vervolgens de configuratie alleen toe op deze projecten. Wanneer deze configuratie is geselecteerd, zijn IntelliSense en de build- en foutopsporingsopdrachten alleen van toepassing op die opgegeven projecten.

Problemen met CMake-cache oplossen

Als u meer informatie nodig hebt over de status van de CMake-cache om een probleem vast te stellen, opent u het hoofdmenu van CMake of het contextmenu CMakeLists.txt in Solution Explorer om een van deze opdrachten uit te voeren:

• Cache weergeven opent het CMakeCache.txt bestand vanuit de hoofdmap van de build in de editor. (Alle wijzigingen die u hier aanbrengt om te CMakeCache.txt worden gewist als u de cache schoont. Als u wijzigingen wilt aanbrengen die behouden blijven nadat de cache is opgeschoond, raadpleegt u CMake-instellingen aanpassen.)

• Cachemap openen opent een Verkenner-venster naar de hoofdmap van de build.

• Clean Cache verwijdert de hoofdmap van de build, zodat de volgende CMake-configuratiestap begint vanuit een schone cache.

• Cache genereren dwingt de generatiestap om te worden uitgevoerd, zelfs als Visual Studio de omgeving als bijgewerkt beschouwt.

Het automatisch genereren van de cache kan worden uitgeschakeld in het dialoogvenster Hulpmiddelen > Options > CMake > Algemeen.

Compilatie van één bestand

Als u één bestand in een CMake-project wilt maken, klikt u met de rechtermuisknop op het bestand in Solution Explorer. Kies Compileren in het pop-upmenu. U kunt ook het momenteel geopende bestand in de editor maken met behulp van het hoofdmenu CMake:

CMake uitvoeren vanaf de opdrachtregel

Als u CMake hebt geïnstalleerd vanuit het Installatieprogramma van Visual Studio, kunt u deze uitvoeren vanaf de opdrachtregel door de volgende stappen uit te voeren:

1. Voer het juiste vsdevcmd.bat-bestand (x86/x64) uit. Zie Bouwen op de opdrachtregelvoor meer informatie.

2. Schakel over naar de uitvoermap.

3. Voer CMake uit om uw app te bouwen of te configureren.

In Visual Studio 2015 kunnen Visual Studio-gebruikers een CMake-generator gebruiken om MSBuild-projectbestanden te genereren, die de IDE vervolgens gebruikt voor IntelliSense, bladeren en compilatie.