Dela via

Open Folder-stöd för C++-byggsystem i Visual Studio

Funktionen Öppna mapp är tillgänglig i Visual Studio 2017 och senare.

I Visual Studio 2017 och senare kan du öppna en mapp med källfiler och omedelbart börja koda med stöd för IntelliSense, bläddra, omstrukturera, felsöka och så vidare. När du redigerar, skapar, flyttar eller tar bort filer spårar Visual Studio ändringarna automatiskt och uppdaterar kontinuerligt sitt IntelliSense-index. Inga .sln- eller .vcxproj filer läses in. Om det behövs kan du ange anpassade uppgifter samt skapa och starta parametrar via enkla .json filer. Med den här funktionen kan du integrera alla byggsystem från tredje part i Visual Studio. Allmän information om Öppna mapp finns i Utveckla kod i Visual Studio utan projekt eller lösningar.

CMake och Qt

CMake är integrerat i Visual Studio IDE som en komponent i C++-skrivbordsarbetsbelastningen. Arbetsflödet för CMake är inte identiskt med arbetsflödet som beskrivs i den här artikeln. Om du använder CMake kan du läsa CMake-projekt i Visual Studio. Du kan också använda CMake för att skapa Qt-projekt, eller så kan du använda Qt Visual Studio-tillägget för antingen Visual Studio 2015 eller Visual Studio 2017.

Andra byggsystem

Om du vill använda Visual Studio IDE med ett byggsystem eller kompilatorverktyg som inte stöds direkt från huvudmenyn väljer du Arkiv | Öppna | Mapp eller tryck på Ctrl + Skift + Alt + O. Navigera till mappen som innehåller dina källkodsfiler. Om du vill skapa projektet, konfigurera IntelliSense och ange felsökningsparametrar lägger du till tre JSON-filer:

Fil Beskrivning
CppProperties.json Ange anpassad konfigurationsinformation för surfning. Skapa den här filen om det behövs i rotprojektmappen. (Används inte i CMake-projekt.)
tasks.vs.json Ange anpassade byggkommandon. Nås via snabbmenyalternativet Konfigurera uppgifter i Solution Explorer.
launch.vs.json Ange kommandoradsargument för felsökningsprogrammet. Via snabbmenyalternativet Solution ExplorerInställningar för felsökning och start.

Konfigurera kodnavigering med CppProperties.json

För att IntelliSense och webbläsarbeteende som Gå till definition ska fungera korrekt måste Visual Studio veta vilken kompilator du använder, var systemhuvudena finns och var eventuella ytterligare inkluderingsfiler finns om de inte finns direkt i mappen som du har öppnat (arbetsytans mapp). Om du vill ange en konfiguration kan du välja Hantera konfigurationer i listrutan i huvudverktygsfältet:

Listrutan Konfiguration i verktygsfältet som visar valet Hantera konfigurationer.

Visual Studio erbjuder följande standardkonfigurationer:

Lägg till konfiguration i dialogrutan CppProperties, som visar en lista över standardkonfigurationer: x86-Debug, x86-Release, x64-Debug, x64-Release och så vidare.

Om du till exempel väljer x64-Debug skapar Visual Studio en fil med namnet CppProperties.json i rotprojektmappen:

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

Den här konfigurationen ärver miljövariablerna i Kommandotolken för Visual Studio x64 Developer. En av dessa variabler är INCLUDE och du kan referera till den här med hjälp av makrot ${env.INCLUDE} . Egenskapen includePath talar om för Visual Studio var du ska leta efter alla källor som behövs för IntelliSense. I det här fallet står det "titta i alla kataloger som anges av variabeln INCLUDE-miljö och även alla kataloger i det aktuella arbetsmappsträdet". Egenskapen name är det namn som visas i listrutan och kan vara vad du vill. Egenskapen defines ger tips till IntelliSense när den stöter på villkorsstyrda kompileringsblock. Egenskapen intelliSenseMode innehåller några ytterligare tips baserat på kompilatortypen. Det finns flera alternativ för MSVC, GCC och Clang.

Anmärkning

Om Visual Studio verkar ignorera inställningar i CppProperties.jsonkan du prova att lägga till ett undantag i .gitignore-filen så här: !/CppProperties.json.

Standardkonfiguration för MinGW-w64

Om du lägger till konfigurationen MinGW-W64 ser JSON ut så här:

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

Observera blocket environments . Den definierar egenskaper som fungerar som miljövariabler och är tillgängliga inte bara i CppProperties.json-filen , utan även i de andra konfigurationsfilerna task.vs.json och launch.vs.json. Konfigurationen Mingw64 ärver mingw_w64 miljön och använder dess INCLUDE egenskap för att ange värdet för includePath. Du kan lägga till andra sökvägar till den här matrisegenskapen efter behov.

Egenskapen intelliSenseMode är inställd på ett värde som är lämpligt för GCC. Mer information om alla dessa egenskaper finns i schemareferensen CppProperties.

När allt fungerar korrekt visas IntelliSense från GCC-headers när du för muspekaren över en typ.

Skärmbild av ett popup-fönster i GCC IntelliSense som visar rubrikdokumentationen.

Aktivera IntelliSense-diagnostik

Om du inte ser den IntelliSense som du förväntar dig kan du felsöka genom att gå till Verktyg>Alternativ>Textredigerare>C/C++>Avancerat och ange Aktivera loggning till true. Börja med att prova att ange loggningsnivå till 5 och loggningsfilter till 8.

Dialogrutan Alternativ som visar inställningarna för diagnostikloggning.

Utdata skickas till utdatafönstret och visas när du väljer *Visa utdata från: Visual C++-logg. Utdata innehåller bland annat listan över de faktiska inkluderingssökvägar som IntelliSense försöker använda. Om sökvägarna inte matchar sökvägarna i CppProperties.jsonkan du prova att stänga mappen och ta bort .vs-undermappen som innehåller cachelagrade webbdata.

Definiera bygguppgifter med tasks.vs.json

Du kan automatisera byggskript eller andra externa åtgärder på de filer som du har på din aktuella arbetsyta genom att köra dem som uppgifter direkt i IDE. Du kan konfigurera en ny uppgift genom att högerklicka på en fil eller mapp och välja Konfigurera uppgifter.

Snabbmenyn i Solution Explorer med kommandot Konfigurera uppgifter.

Detta skapar (eller öppnar) filentasks.vs.json i mappen .vs som Visual Studio skapar i rotprojektmappen. Du kan definiera valfri godtycklig aktivitet i den här filen och sedan anropa den från snabbmenyn i Solution Explorer . För att fortsätta GCC-exemplet visar följande kodfragment en fullständig tasks.vs.json fil med som enskild uppgift som anropar g++.exe för att skapa ett projekt. Anta att projektet innehåller en enda fil med namnet hello.cpp.

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

JSON-filen placeras i . vs-undermappen. Om du vill se mappen klickar du på knappen Visa alla filer överst i Solution Explorer. Du kan köra den här uppgiften genom att högerklicka på rotnoden i Solution Explorer och välja skapa hello. När uppgiften är klar bör du se en ny fil hello.exe i Solution Explorer.

Du kan definiera många typer av uppgifter. I följande exempel visas en tasks.vs.json fil som definierar en enskild uppgift. taskLabel definierar namnet som visas på snabbmenyn. appliesTo definierar vilka filer som kommandot kan utföras på. Egenskapen command refererar till COMSPEC-miljövariabeln, som identifierar sökvägen för konsolen (cmd.exe i Windows). Du kan också referera till miljövariabler som deklareras i CppProperties.json eller CMakeSettings.json. Egenskapen args anger vilken kommandorad som ska anropas. Makrot ${file} hämtar den valda filen i Solution Explorer. I följande exempel visas filnamnet för den markerade .cpp filen.

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

Efter att du har sparat tasks.vs.json kan du högerklicka på valfri .cpp-fil i mappen, välja Visa filnamn på snabbmenyn och se filnamnet visas i fönstret Utdata.

Mer information finns iTasks.vs.json schemareferens.

Konfigurera felsökningsparametrar med launch.vs.json

Om du vill anpassa programmets kommandoradsargument och felsökningsinstruktioner högerklickar du på den körbara filen i Solution Explorer och väljer Felsöka och Starta inställningar. Detta öppnar en befintlig launch.vs.json fil, eller om det inte finns någon, skapas en ny fil med en uppsättning minimala startinställningar. Först får du välja vilken typ av felsökningssession du vill konfigurera. För felsökning av ett MinGw-w64-projekt väljer vi C/C++ Launch for MinGW/Cygwin (gdb). Detta skapar en startkonfiguration för att använda gdb.exe med några kvalificerade antaganden om standardvärden. Ett av dessa standardvärden är MINGW_PREFIX. Du kan ersätta den literala sökvägen (som visas nedan) eller så kan du definiera en MINGW_PREFIX egenskap i 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
    }
  ]
}

Börja felsöka genom att välja den körbara filen i listrutan för felsökning och klicka sedan på den gröna pilen:

Listrutan Felsökningsmål i verktygsfältet visar den gröna pilen för att starta felsökningsprogrammet.

Du bör se dialogrutan Initiera felsökningsprogram och sedan ett externt konsolfönster som kör programmet.

Mer information finns ilaunch.vs.json schemareferens.

Starta andra körbara filer

Du kan definiera startinställningar för alla körbara filer på datorn. I följande exempel startas 7za och ytterligare argument anges genom att de läggs till i JSON-matrisen args :

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

När du sparar den här filen visas den nya konfigurationen i listrutan Felsökningsmål och du kan välja den för att starta felsökningsprogrammet. Du kan skapa så många felsökningskonfigurationer som du vill för valfritt antal körbara filer. Om du trycker på F5 nu startar felsökningsprogrammet och träffar alla brytpunkter som du kanske redan har angett. Alla välbekanta felsökningsfönster och deras funktioner är nu tillgängliga.