Delen via

Ondersteuning voor Open Folder voor C++ buildsystemen in Visual Studio

De functie Map openen is beschikbaar in Visual Studio 2017 en hoger.

In Visual Studio 2017 en hoger kunt u met de functie Map openen een map met bronbestanden openen en onmiddellijk beginnen met coderen met ondersteuning voor IntelliSense, bladeren, herstructureren, foutopsporing, enzovoort. Wanneer u bestanden bewerkt, maakt, verplaatst of verwijdert, houdt Visual Studio de wijzigingen automatisch bij en werkt de IntelliSense-index continu bij. Er worden geen .sln of .vcxproj bestanden geladen; Indien nodig kunt u aangepaste taken opgeven en parameters bouwen en starten via eenvoudige .json bestanden. Met deze functie kunt u elk buildsysteem van derden integreren in Visual Studio. Zie Code ontwikkelen in Visual Studio zonder projecten of oplossingen voor algemene informatie over Open Folder.

CMake en Qt

CMake is geïntegreerd in de Visual Studio IDE als onderdeel van de C++-desktopworkload. De werkstroom voor CMake is niet identiek aan de werkstroom die in dit artikel wordt beschreven. Als u CMake gebruikt, raadpleegt u CMake-projecten in Visual Studio. U kunt ook CMake gebruiken om Qt-projecten te bouwen of u kunt de Qt Visual Studio-extensie gebruiken voor Visual Studio 2015 of Visual Studio 2017.

Andere buildsystemen

Als u de Visual Studio IDE wilt gebruiken met een buildsysteem of compilerhulpprogrammaset die niet rechtstreeks wordt ondersteund in het hoofdmenu, selecteert u Bestand | Openen | Map of druk op Ctrl+Shift+Alt+O. Navigeer naar de map die de broncodebestanden bevat. Als u het project wilt bouwen, configureert u IntelliSense en stelt u parameters voor foutopsporing in. U voegt drie JSON-bestanden toe:

Bestand Beschrijving
CppProperties.json Geef aangepaste configuratiegegevens op voor browsen. Maak dit bestand, indien nodig, in de hoofdprojectmap. (Niet gebruikt in CMake-projecten.)
tasks.vs.json Geef aangepaste buildopdrachten op. Geopend via het contextmenu-item Van Solution Explorer: Taken configureren.
launch.vs.json Geef opdrachtregelargumenten op voor het foutopsporingsprogramma. Toegankelijk via het contextmenu-item Solution ExplorerFoutopsporing en Startinstellingen.

Codenavigatie configureren met CppProperties.json

Voor intelliSense en browsegedrag, zoals Go to Definition , moet Visual Studio weten welke compiler u gebruikt, waar de systeemkopteksten zich bevinden en waar eventuele extra include-bestanden zich bevinden als ze zich niet rechtstreeks in de map bevinden die u hebt geopend (de werkruimtemap). Als u een configuratie wilt opgeven, kunt u Configuraties beheren kiezen in de vervolgkeuzelijst op de hoofdwerkbalk:

Configuratievervolgkeuzelijst op de werkbalk met de optie Configuraties beheren.

Visual Studio biedt de volgende standaardconfiguraties:

Voeg configuratie toe aan het dialoogvenster CppProperties, met een lijst met standaardconfiguraties: x86-Debug, x86-Release, x64-Debug, x64-Release, enzovoort.

Als u bijvoorbeeld x64-Debug kiest, maakt Visual Studio een bestand met de naam CppProperties.json in de hoofdprojectmap:

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

Deze configuratie neemt de omgevingsvariabelen over van de Visual Studio x64 Developer-opdrachtprompt. Een van deze variabelen is INCLUDE en u kunt ernaar verwijzen met behulp van de ${env.INCLUDE} macro. De includePath eigenschap vertelt Visual Studio waar moet worden gezocht naar alle bronnen die nodig zijn voor IntelliSense. In dit geval staat 'zoek in alle mappen die zijn opgegeven door de INCLUDE-omgevingsvariabele en ook alle mappen in de huidige werkmapstructuur'. De name eigenschap is de naam die wordt weergegeven in de vervolgkeuzelijst en kan alles zijn wat u wilt. De defines eigenschap biedt hints voor IntelliSense wanneer deze voorwaardelijke compilatieblokken tegenkomt. De intelliSenseMode eigenschap biedt enkele aanvullende hints op basis van het compilertype. Er zijn verschillende opties beschikbaar voor MSVC, GCC en Clang.

Opmerking

Als Visual Studio instellingen in CppProperties.jsonlijkt te negeren, voegt u als volgt een uitzondering toe aan uw .gitignore-bestand: !/CppProperties.json

Standaardconfiguratie voor MinGW-w64

Als u de MinGW-W64-configuratie toevoegt, ziet de JSON er als volgt uit:

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

Let op het environments blok. Het definieert eigenschappen die zich gedragen als omgevingsvariabelen en zijn niet alleen beschikbaar in het CppProperties.json bestand, maar ook in de andere configuratiebestanden task.vs.json en launch.vs.json. De Mingw64 configuratie neemt de mingw_w64 omgeving over en gebruikt INCLUDE de eigenschap om de waarde voor includePathop te geven. U kunt indien nodig andere paden toevoegen aan deze matrixeigenschap.

De intelliSenseMode eigenschap is ingesteld op een waarde die geschikt is voor GCC. Zie de CppProperties-schemareferentie voor meer informatie over al deze eigenschappen.

Wanneer alles correct werkt, ziet u IntelliSense in de GCC-headers wanneer u de muisaanwijzer over een type beweegt:

Schermopname van een GCC IntelliSense-pop-up met de koptekstdocumentatie.

Diagnostische gegevens van IntelliSense inschakelen

Als u de verwachte IntelliSense niet ziet, kunt u het probleem oplossen door naar Hulpmiddelen>Opties>Teksteditor>C/C++>Geavanceerd te gaan en Logboekregistratie in te stellen op true. U begint door logboekregistratieniveau in te stellen op 5 en filters voor logboekregistratie in te stellen op 8.

Dialoogvenster Opties dat de instellingen voor diagnostische logging toont.

Uitvoer wordt doorgesluisd naar het uitvoervenster en is zichtbaar wanneer u *Uitvoer weergeven van: Visual C++-logboek kiest. De uitvoer bevat onder andere de lijst met feitelijke insluitpaden die IntelliSense probeert te gebruiken. Als de paden niet overeenkomen met de paden in CppProperties.json, sluit u de map en verwijdert u de .vs-submap die browsegegevens in de cache bevat.

Buildtaken definiëren met tasks.vs.json

U kunt build-scripts of andere externe bewerkingen automatiseren op de bestanden die u in uw huidige werkruimte hebt door ze direct in de IDE als taken uit te voeren. U kunt een nieuwe taak configureren door met de rechtermuisknop op een bestand of map te klikken en Taken configureren te selecteren.

Het snelmenu van Solution Explorer met de opdracht 'Configureer taken'.

Hiermee maakt (of opent) u het tasks.vs.json bestand in de map .vs die Visual Studio maakt in de hoofdprojectmap. U kunt elke willekeurige taak in dit bestand definiëren en vervolgens aanroepen vanuit het contextmenu van Solution Explorer . Als u het GCC-voorbeeld wilt voortzetten, ziet u in het volgende fragment een volledig tasks.vs.json bestand met één taak die g++.exe aanroept om een project te bouwen. Stel dat het project één bestand bevat met de naam hello.cpp.

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

Het JSON-bestand wordt in het .vs-submapje geplaatst. Als u die map wilt zien, klikt u boven in Solution Explorer op de knop Alle bestanden weergeven. U kunt deze taak uitvoeren door met de rechtermuisknop op het hoofdknooppunt in Solution Explorer te klikken en build hello te kiezen. Wanneer de taak is voltooid, ziet u een nieuw bestand hello.exe in Solution Explorer.

U kunt allerlei soorten taken definiëren. In het volgende voorbeeld ziet u een tasks.vs.json-bestand dat één taak definieert. taskLabel definieert de naam die wordt weergegeven in het contextmenu. appliesTo definieert op welke bestanden de opdracht kan worden uitgevoerd. De command eigenschap verwijst naar de omgevingsvariabele COMSPEC, waarmee het pad voor de console (cmd.exe in Windows) wordt geïdentificeerd. U kunt ook verwijzen naar omgevingsvariabelen die zijn gedeclareerd in CppProperties.json of CMakeSettings.json. De args eigenschap geeft de opdrachtregel op die moet worden aangeroepen. De ${file} macro haalt het geselecteerde bestand op in Solution Explorer. In het volgende voorbeeld wordt de bestandsnaam van het geselecteerde .cpp-bestand weergegeven.

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

Nadat u tasks.vs.json hebt opgeslagen, kunt u met de rechtermuisknop op een .cpp-bestand in de map klikken, Echo bestandsnaam kiezen in het contextmenu en de bestandsnaam zien die wordt weergegeven in het venster Uitvoer.

Zie Tasks.vs.json schemareferentie voor meer informatie.

Parameters voor foutopsporing configureren met launch.vs.json

Als u de opdrachtregelargumenten en foutopsporingsinstructies van uw programma wilt aanpassen, klikt u met de rechtermuisknop op het uitvoerbare bestand in Solution Explorer en selecteert u Debug and Launch Settings. Hiermee opent u een bestaand launch.vs.json-bestand of als er geen bestaat, wordt er een nieuw bestand gemaakt met een set minimale startinstellingen. Eerst krijgt u een keuze uit welk type foutopsporingssessie u wilt configureren. Voor foutopsporing van een MinGw-w64-project kiezen we C/C++ Launch for MinGW/Cygwin (gdb). Hiermee maakt u een startconfiguratie voor het gebruik van gdb.exe met een aantal gegronde schattingen voor standaardwaarden. Een van deze standaardwaarden is MINGW_PREFIX. U kunt het letterlijke pad (zoals hieronder weergegeven) vervangen of u kunt een MINGW_PREFIX eigenschap definiëren 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
    }
  ]
}

Als u foutopsporing wilt starten, kiest u het uitvoerbare bestand in de vervolgkeuzelijst voor foutopsporing en klikt u vervolgens op de groene pijl:

Vervolgkeuzelijst voor foutopsporing in de werkbalk met de groene pijl om het foutopsporingsprogramma te starten.

U ziet het dialoogvenster Initializing Debugger en vervolgens een extern consolevenster waarop uw programma wordt uitgevoerd.

Zie launch.vs.json schemareferentie voor meer informatie.

Andere uitvoerbare bestanden starten

U kunt startinstellingen definiëren voor elk uitvoerbaar bestand op uw computer. In het volgende voorbeeld wordt 7za gestart en worden extra argumenten opgegeven door deze toe te voegen aan de args JSON-matrix:

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

Wanneer u dit bestand opslaat, wordt de nieuwe configuratie weergegeven in de vervolgkeuzelijst Doel voor foutopsporing en kunt u het selecteren om het foutopsporingsprogramma te starten. U kunt zoveel configuraties voor foutopsporing maken als u wilt, voor een willekeurig aantal uitvoerbare bestanden. Als u nu op F5 drukt, wordt het foutopsporingsprogramma gestart en wordt een onderbrekingspunt bereikt dat u mogelijk al hebt ingesteld. Alle bekende foutopsporingsprogrammavensters en hun functionaliteit zijn nu beschikbaar.

  • Last updated on