Projekty CMake w programie Visual C++CMake projects in Visual C++

W tym artykule założono, że czytelnik zna za pomocą narzędzia CMake, narzędzie Międzyplatformowe, typu open-source Definiowanie procesów kompilacji, które są uruchamiane na wielu platformach.This article assumes that you are familiar with CMake, a cross-platform, open-source tool for defining build processes that run on multiple platforms.

W programie Visual Studio 2015, Visual Studio użytkownicy mogą używać generatora CMake do generowania plików projektu MSBuild, które IDE następnie zużywa dla technologii IntelliSense, przeglądanie i kompilacji.In Visual Studio 2015, Visual Studio users can use a CMake generator to generate MSBuild project files, which the IDE then consumes for IntelliSense, browsing, and compilation.

Począwszy od programu Visual Studio 2017, Visual C++ Tools for CMake składnik używa Otwórz Folder funkcję, aby umożliwić korzystają z plików projektu narzędzia CMake (na przykład pliku CMakeLists.txt) bezpośrednio na potrzeby środowiska IDE funkcja IntelliSense i przeglądania.Starting in Visual Studio 2017, the Visual C++ Tools for CMake component uses the Open Folder feature to enable the IDE to consume CMake project files (such as CMakeLists.txt) directly for the purposes of IntelliSense and browsing. Jeśli używasz generator programu Visual Studio, tymczasowy plik projektu zostanie wygenerowany i przekazane do msbuild.exe, ale nigdy nie jest załadowany do celów przeglądaniu lub IntelliSense.If you use a Visual Studio generator, a temporary project file is generated and passed to msbuild.exe, but is never loaded for IntelliSense or browsing purposes.

Visual Studio 2017 w wersji 15.3: Pomoc techniczna jest dostępna dla generatorów Ninja i programu Visual Studio.Visual Studio 2017 version 15.3: Support is provided for both Ninja and Visual Studio generators.

Visual Studio 2017 w wersji 15.4: Dodano obsługę narzędzia CMake w systemie Linux.Visual Studio 2017 version 15.4: Support is added for CMake on Linux. Aby uzyskać więcej informacji, zobacz Konfigurowanie projektu CMake systemu Linux.For more information, see Configure a Linux CMake Project.

Visual Studio 2017 w wersji 15.5: Dodano obsługę importowanie istniejących pamięć podręczną CMake.Visual Studio 2017 version 15.5: Support is added for importing an existing CMake cache. Program Visual Studio wyodrębnia niestandardowe zmienne i automatycznie tworzy plik CMakeSettings.json wstępnie wypełnione.Visual Studio automatically extracts customized variables and creates a pre-populated CMakeSettings.json file.

Visual Studio 2017 w wersji 15.7: Dodano obsługę wyłączenie pamięci podręcznej automatycznego generowania widok elementów docelowych w Eksploratora rozwiązańi kompilacja pojedynczego pliku.Visual Studio 2017 version 15.7: Support is added for disabling automatic cache generation, Targets View in Solution Explorer, and single-file compilation.

InstalacjaInstallation

Visual C++ Tools for CMake jest instalowany domyślnie w jako część programowanie aplikacji klasycznych w języku C++ obciążenia.Visual C++ Tools for CMake is installed by default as part of the Desktop development with C++ workload.

Składnik narzędzia CMake w obciążeniu C++ na komputerach

Integracja środowiska IDEIDE Integration

Po wybraniu pliku | Otwórz | Folder aby otworzyć folder zawierający plik CMakeLists.txt, się zdarzyć, następujące elementy:When you choose File | Open | Folder to open a folder containing a CMakeLists.txt file, the following things happen:

  • Program Visual Studio dodaje CMake element menu do menu głównego, za pomocą poleceń do wyświetlania i edytowania skryptów narzędzia CMake.Visual Studio adds a CMake menu item to the main menu, with commands for viewing and editing CMake scripts.
  • Eksplorator rozwiązań wyświetla strukturę folderów i plików.Solution Explorer displays the folder structure and files.
  • Program Visual Studio uruchamia CMake.exe i generuje pamięci podręcznej narzędzia CMake dla domyślnej konfiguracji, czyli x86 debugowania.Visual Studio runs CMake.exe and generates the CMake cache for the default configuration, which is x86 Debug. W wierszu polecenia CMake są wyświetlane w okno danych wyjściowych, wraz z dodatkowych danych wyjściowych z narzędzia CMake.The CMake command line is displayed in the Output Window, along with additional output from CMake. Visual Studio 2017 w wersji 15.7 lub nowszej: generowanie pamięci podręcznej automatycznego można wyłączyć w narzędzia | Opcje | Narzędzie CMake | Ogólne okna dialogowego.Visual Studio 2017 version 15.7 and later: Automatic cache generation can be disabled in the Tools | Options | CMake | General dialog.
  • W tle programu Visual Studio uruchamia do indeksowania plików źródłowych, aby włączyć technologię IntelliSense, informacji o przeglądaniu, Refaktoryzacja i tak dalej.In the background, Visual Studio starts to index the source files to enable IntelliSense, browsing information, refactoring, and so on. Podczas pracy programu Visual Studio monitoruje zmiany w edytorze, a także na dysku w celu synchronizowania jej indeks ze źródłami.As you work, Visual Studio monitors changes in the editor and also on disk to keep its index in sync with the sources.

Możesz otworzyć foldery zawierające dowolną liczbę projekty narzędzia CMake.You can open folders containing any number of CMake projects. Visual Studio wykrywa i skonfiguruje wszystkie pliki CMakeLists.txt "root" w obszarze roboczym.Visual Studio detects and configures all the "root" CMakeLists.txt files in your workspace. Operacje CMake (Konfigurowanie, tworzenie, debugowanie) również funkcji C++ IntelliSense i przeglądania są dostępne dla wszystkich projektów CMake w obszarze roboczym.CMake operations (configure, build, debug) as well as C++ IntelliSense and browsing are available to all CMake projects in your workspace.

Projekt narzędzia CMake z wielu katalogów głównych

Visual Studio 2017 w wersji 15.7 lub nowszej: Możesz również wyświetlić swoje projekty logicznie uporządkowane według elementów docelowych.Visual Studio 2017 version 15.7 and later: You can also view your projects organized logically by targets. Wybierz jest przeznaczony dla widoku z listy rozwijanej w Eksploratora rozwiązań narzędzi:Choose Targets view from the dropdown in the Solution Explorer toolbar:

Przycisk Widok elementów docelowych narzędzia CMake

Importowanie istniejąca pamięć podręcznaImport an existing cache

Podczas importowania istniejącego pliku CMakeCache.txt programu Visual Studio wyodrębnia niestandardowe zmienne i automatycznie tworzy wstępnie wypełnionych CMakeSettings.json na ich podstawie plików.When you import an existing CMakeCache.txt file, Visual Studio automatically extracts customized variables and creates a pre-populated CMakeSettings.json file based on them. Oryginalny pamięci podręcznej nie jest modyfikowany w dowolny sposób i nadal można używać z poziomu wiersza polecenia lub przy użyciu dowolnego narzędzia lub IDE został użyty do jego wygenerowania.The original cache is not modified in any way and can still be used from the command line or with whatever tool or IDE was used to generate it. Nowy plik CMakeSettings.json znajduje się obok projektu głównego pliku CMakeLists.txt.The new CMakeSettings.json file is placed alongside the project’s root CMakeLists.txt. Program Visual Studio generuje nową pamięć podręczną na podstawie pliku ustawień.Visual Studio generates a new cache based the settings file.

Visual Studio 2017 w wersji 15.7 lub nowszej: możesz zastąpić Generowanie automatyczne pamięci podręcznej w narzędzia | Opcje | Narzędzie CMake | Ogólne okna dialogowego.Visual Studio 2017 version 15.7 and later: you can override automatic cache generation in the Tools | Options | CMake | General dialog.

Nie wszystkie elementy w pamięci podręcznej jest importowany.Not everything in the cache is imported. Właściwości, takie jak generator i lokalizację kompilatorów są zastępowane przy użyciu ustawień domyślnych, które są znane do pracy ze środowiska IDE.Properties such as the generator and the location of the compilers are replaced with defaults that are known to work well with the IDE.

Aby zaimportować istniejąca pamięć podręcznaTo import an existing cache

  1. W menu głównym wybierz pliku | Otwórz | Narzędzie CMake:From the main menu, choose File | Open | CMake:

    Otwórz narzędzie CMakeOpen CMake

    Spowoduje to przejście importu CMake z pamięci podręcznej kreatora.This brings up the Import CMake from Cache wizard.

  2. Przejdź do pliku CMakeCache.txt, który chcesz zaimportować, a następnie kliknij przycisk OK.Navigate to the CMakeCache.txt file that you want to import, and then click OK. Importowania projektu narzędzia CMake z pamięci podręcznej pojawi się Kreator:The Import CMake Project from Cache wizard appears:

    Importowanie pamięci podręcznej narzędzia CMakeImport a CMake cache

    Po zakończeniu działania kreatora, można wyświetlić nowy plik CMakeCache.txt w Eksploratora rozwiązań obok głównego pliku CMakeLists.txt w projekcie.When the wizard completes, you can see the new CMakeCache.txt file in Solution Explorer next to the root CMakeLists.txt file in your project.

Kompilowanie projektów narzędzia CMakeBuilding CMake projects

Aby skompilować projekt CMake, masz następujące opcje:To build a CMake project, you have these choices:

  1. Wybierz element docelowy w debugowania listy rozwijanej i naciśnij klawisz F5, lub kliknij przycisk Uruchom przycisku (zielony trójkąt).Select the target in the Debug dropdown and press F5, or click the Run (green triangle) button. Automatycznie kompilacje projektu po pierwsze, podobnie jak rozwiązanie programu Visual Studio.The project automatically builds first, just like a Visual Studio solution.
  2. Kliknij prawym przyciskiem myszy pliku CMakeLists.txt i wybierz pozycję kompilacji z menu kontekstowego.Right click on the CMakeLists.txt and select Build from the context menu. Jeśli masz wiele elementów docelowych w strukturze folderów, użytkownik może tworzyć wszystkie lub tylko jeden określony element docelowy, lubIf you have multiple targets in your folder structure, you can choose to build all or only one specific target, or
  3. W menu głównym wybierz kompilacji | Tworzenie rozwiązania (F7 lub Ctrl + Shift + B).From the main menu, select Build | Build Solution (F7 or Ctrl+Shift+B). Upewnij się, czy docelowych narzędzia CMake została już wybrana w element startowy liście rozwijanej ogólne paska narzędzi.Make sure that a CMake target is already selected in the Startup Item dropdown in the General toolbar.

Polecenia menu kompilacji CMakeCMake build menu command

Po wybraniu generator programu Visual Studio dla aktywnej konfiguracji MSBuild.exe jest wywoływana z -m -v:minimal argumentów.When a Visual Studio generator is selected for the active configuration, MSBuild.exe is invoked with -m -v:minimal arguments. Dostosowywanie kompilacji, w pliku CMakeSettings.json, można określić dodatkowe argumenty wiersza polecenia do przekazania do systemu kompilacji, za pośrednictwem buildCommandArgs właściwości:To customize the build, inside the CMakeSettings.json file, you can specify additional command line arguments to be passed to the build system via the buildCommandArgs property:

"buildCommandArgs": "-m:8 -v:minimal -p:PreferredToolArchitecture=x64"

Jak można oczekiwać wyników kompilacji są wyświetlane w okno danych wyjściowych i lista błędów.As you would expect, build results are shown in the Output Window and Error List.

Błędy kompilacji CMakeCMake build errors

W folderze o wiele obiektów docelowych kompilacji, można wybrać kompilacji elementu na CMake menu lub CMakeLists.txt menu kontekstowym, aby określić, które docelowej narzędzia CMake do kompilacji.In a folder with multiple build targets, you can choose the Build item on the CMake menu or the CMakeLists.txt context menu to specify which CMake target to build. Naciśnięcie klawisza Ctrl + Shift + B w CMake projekt jest kompilowany bieżący aktywny dokument.Pressing Ctrl+Shift+B in a CMake project builds the current active document.

Debugowanie projektuDebug the project

Aby debugować projekt CMake, wybierz żądaną konfiguracją i naciśnij klawisz F5, lub naciśnij Uruchom przycisku na pasku narzędzi.To debug a CMake project, choose the desired configuration and press F5, or press the Run button in the toolbar. Jeśli Uruchom przycisk jest wyświetlany komunikat "Wybierz element startowy", wybierz strzałkę listy rozwijanej i wybierz cel, który chcesz uruchomić.If the Run button says "Select Startup Item", select the dropdown arrow and choose the target that you want to run. (W projekcie programu CMake, "bieżący dokument" opcja jest prawidłowa tylko dla plików .cpp.)(In a CMake project, the "Current document" option is only valid for .cpp files.)

Przycisk Uruchom narzędzie CMakeCMake run button

Uruchom lub F5 polecenia najpierw skompilować projekt, jeśli zostały zmienione od poprzedniej kompilacji.The Run or F5 commands first build the project if changes have been made since the previous build.

Konfigurowanie narzędzia CMake sesjami debugowaniaConfigure CMake debugging sessions

Wszystkie elementy docelowe z pliku wykonywalnego narzędzia CMake są wyświetlane w element startowy liście rozwijanej ogólne paska narzędzi.All executable CMake targets are shown in the Startup Item dropdown in the General toolbar. Aby rozpocząć sesję debugowania, po prostu zaznacz jedną i uruchomić debugera.To start a debugging session, just select one and launch the debugger.

Narzędzie CMake uruchamiania elementu z listy rozwijanejCMake startup item dropdown

Można również uruchomić sesję debugowania z menu Narzędzia CMake.You can also start a debug session from the CMake menus.

Aby dostosować ustawienia debugera dla dowolnego pliku wykonywalnego docelowych narzędzia CMake w projekcie, kliknij prawym przyciskiem myszy w określonym pliku CMakeLists.txt, a następnie wybierz ustawienia debugowania i uruchamiania.To customize the debugger settings for any executable CMake target in your project, right-click on the specific CMakeLists.txt file and select Debug and Launch Settings. Po wybraniu docelowych narzędzia CMake w podmenu, zostanie utworzony plik o nazwie pliku launch.vs.json.When you select a CMake target in the submenu, a file called launch.vs.json is created. Ten plik jest wstępnie wypełniane przy użyciu informacji o docelowej narzędzia CMake, wybrana przez Ciebie i pozwala określić dodatkowe parametry, takie jak argumenty programu lub typ debugera.This file is pre-populated with information about the CMake target you have selected and allows you to specify additional parameters such as program arguments or debugger type. Aby odwołać się dowolnym kluczu w pliku CMakeSettings.json, należy poprzedzić go za pomocą "Narzędzia CMake."To reference any key in a CMakeSettings.json file, preface it with "CMake." in launch.vs.json.in launch.vs.json. Poniższy kod przedstawia pliku prostego pliku launch.vs.json, który pobiera wartość klucza "remoteCopySources" w pliku CMakeSettings.json dla aktualnie wybranej konfiguracji:The following example shows a simple launch.vs.json file that pulls in the value of the "remoteCopySources" key in the CMakeSettings.json file for the currently selected configuration:

{
  "version": "0.2.1",
  "defaults": {},
  "configurations": [
    {
      "type": "default",
      "project": "CMakeLists.txt",
      "projectTarget": "CMakeHelloWorld.exe (Debug\\CMakeHelloWorld.exe)",
      "name": "CMakeHelloWorld.exe (Debug\\CMakeHelloWorld.exe)",
      "args": ["${cmake.remoteCopySources}"]
    }
  ]
}

Bezpośrednio po zapisaniu pliku launch.vs.json zapis jest tworzony w element startowy lista rozwijana z nową nazwą.As soon as you save the launch.vs.json file, an entry is created in the Startup Item dropdown with the new name. Podczas edycji pliku launch.vs.json, można tworzyć, jak wiele konfiguracji debugowania, jak dowolną liczbę elementów docelowych narzędzia CMake.By editing the launch.vs.json file, you can create as many debug configurations as you like for any number of CMake targets.

Visual Studio 2017 w wersji 15.4: pliku Launch.vs.json obsługuje zmienne, które są zadeklarowane w pliku CMakeSettings.json (patrz poniżej) i które mają zastosowanie do konfiguracji aktualnie wybrany.Visual Studio 2017 version 15.4: Launch.vs.json supports variables that are declared in CMakeSettings.json (see below) and that are applicable to the currently-selected configuration. Ma również klucz o nazwie "currentDir", który ustawia bieżący katalog uruchamiania aplikacji:It also has a key named "currentDir", which sets the current directory of the launching app:

{
  "type": "default",
  "project": "CMakeLists.txt",
  "projectTarget": "CMakeHelloWorld1.exe (C:\\Users\\satyan\\CMakeBuilds\\Test\\Debug\\CMakeHelloWorld1.exe)",
  "name": "CMakeHelloWorld1.exe (C:\\Users\\satyan\\CMakeBuilds\\Test\\Debug\\CMakeHelloWorld1.exe)",
  "currentDir": "${env.USERPROFILE}\\CMakeBuilds\\${workspaceHash}"
}

Po uruchomieniu aplikacji, a wartość currentDir jest podobny doWhen you run the app, the value of currentDir is something similar to

C:\Users\satyan\7f14809a-2626-873e-952e-cdf038211175\

Edytowanie pliku CMakeLists.txt plikówEditing CMakeLists.txt files

Aby edytować plik CMakeLists.txt, kliknij prawym przyciskiem myszy plik w Eksploratora rozwiązań i wybierz polecenie Otwórz.To edit a CMakeLists.txt file, right click on the file in Solution Explorer and choose Open. Jeśli wprowadzisz zmiany w pliku paska stanu żółty pojawia się i informuje o spowoduje zaktualizowanie funkcji IntelliSense i daje możliwość anulowania operacji aktualizacji.If you make changes to the file, a yellow status bar appears and informs you that IntelliSense will update, and gives you an opportunity to cancel the update operation. Aby uzyskać informacji dotyczących pliku CMakeLists.txt, zobacz dokumentacji narzędzia CMake.For information about CMakeLists.txt, see the CMake documentation.

Edytowanie pliku CMakeLists.txtCMakeLists.txt file editing

Bezpośrednio po zapisaniu pliku kroku konfiguracji automatycznie ponownie uruchomiona i wyświetli informacje zawarte w dane wyjściowe okna.As soon as you save the file, the configuration step automatically runs again and displays information in the Output window. Błędy i ostrzeżenia są wyświetlane w lista błędów lub dane wyjściowe okna.Errors and warnings are shown in the Error List or Output window. Kliknij dwukrotnie błąd w lista błędów można przejść do problematycznych wierszy w pliku CMakeLists.txt.Double-click on an error in the Error List to navigate to the offending line in CMakeLists.txt.

Błędy w pliku CMakeLists.txtCMakeLists.txt file errors

Ustawienia narzędzia CMake i konfiguracje niestandardoweCMake settings and custom configurations

Domyślnie program Visual Studio zawiera sześć domyślnej konfiguracji narzędzia CMake ("x86 debugowanie", "x86 wersja", "x64 debugowanie", "x64-wersja", "Linux-debugowanie" i "Linux-wersja").By default, Visual Studio provides six default CMake configurations ("x86-Debug", "x86-Release", "x64-Debug", "x64-Release", "Linux-Debug" and "Linux-Release"). Te konfiguracje definiują, jak CMake.exe jest wywoływana w celu utworzenia pamięci podręcznej narzędzia CMake dla danego projektu.These configurations define how CMake.exe is invoked to create the CMake cache for a given project. Aby zmodyfikować te konfiguracje, lub Utwórz nową konfigurację niestandardowe, wybierz opcję CMake | Zmień ustawienia narzędzia CMake, a następnie wybierz plik CMakeLists.txt, które ustawienia dotyczą.To modify these configurations, or create a new custom configuration, choose CMake | Change CMake Settings, and then choose the CMakeLists.txt file that the settings apply to. Zmień ustawienia narzędzia CMake polecenia jest także dostępny w menu kontekstowym pliku w Eksploratora rozwiązań.The Change CMake Settings command is also available on the file's context menu in Solution Explorer. To polecenie tworzy plik CMakeSettings.json w folderze projektu.This command creates a CMakeSettings.json file in the project folder. Ten plik jest używany ponowne tworzenie pliku pamięci podręcznej narzędzia CMake, na przykład po czysty operacji.This file is used to re-create the CMake cache file, for example after a Clean operation.

Polecenia menu głównego narzędzia CMake ustawienia zmian

JSON technologia IntelliSense pomaga edytować pliku CMakeSettings.json:JSON IntelliSense helps you edit the CMakeSettings.json file:

IntelliSense CMake JSONCMake JSON IntelliSense

Poniższy przykład pokazuje Przykładowa konfiguracja, który służy jako punkt wyjścia do tworzenia własnego w pliku CMakeSettings.json:The following example shows a sample configuration, which you can use as the starting point to create your own in CMakeSettings.json:

    {
      "name": "x86-Debug",
      "generator": "Ninja",
      "configurationType": "Debug",
      "inheritEnvironments": [ "msvc_x86" ],
      "buildRoot": "${env.USERPROFILE}\\CMakeBuilds\\${workspaceHash}\\build\\${name}",
      "installRoot": "${env.USERPROFILE}\\CMakeBuilds\\${workspaceHash}\\install\\${name}",
      "cmakeCommandArgs": "",
      "buildCommandArgs": "-v",
      "ctestCommandArgs": ""
    },
  1. Nazwa: Nazwa wyświetlana na liście rozwijanej konfiguracji C++.name: the name that appears in the C++ configuration dropdown. Wartość tej właściwości może również służyć jako makra, ${name}, aby określić wartości innych właściwości.This property value can also be used as a macro, ${name}, to specify other property values. Aby uzyskać przykład, zobacz wybrany element buildRoot definicję w pliku CMakeSettings.json.For an example, see the buildRoot definition in CMakeSettings.json.

  2. Generator: mapuje - G przełącznika i określa generator, który ma być używany.generator: maps to the -G switch and specifies the generator to be used. Ta właściwość może również służyć jako makra, ${generator}, aby pomóc określić wartości innych właściwości.This property can also be used as a macro, ${generator}, to help specify other property values. Program Visual Studio obsługuje obecnie następujące generatory CMake:Visual Studio currently supports the following CMake generators:

    • "Ninja""Ninja"
    • "Visual Studio 14 2015""Visual Studio 14 2015"
    • "Visual Studio 14 2015 ARM""Visual Studio 14 2015 ARM"
    • "Win64 programu visual Studio 14 2015""Visual Studio 14 2015 Win64"
    • "Visual Studio 15 2017""Visual Studio 15 2017"
    • "Visual Studio 15 2017 ARM""Visual Studio 15 2017 ARM"
    • "Visual Studio 15 2017 Win64""Visual Studio 15 2017 Win64"

Ponieważ Ninja jest przeznaczona dla szybkości szybkie kompilacji zamiast elastyczności i funkcji, jest ustawiona jako domyślna.Because Ninja is designed for fast build speeds instead of flexibility and function, it is set as the default. Jednak niektóre projekty narzędzia CMake, może być nie można poprawnie tworzyć zawartość przy użyciu Ninja.However, some CMake projects may be unable to correctly build using Ninja. W takiej sytuacji można nakazać narzędzia CMake w celu wygenerowania projektu programu Visual Studio, zamiast tego.If this occurs, you can instruct CMake to generate a Visual Studio project instead.

Aby określić generator programu Visual Studio, otwórz pliku CMakeSettings.json z menu głównego, wybierając CMake | Zmień ustawienia narzędzia CMake.To specify a Visual Studio generator, open the CMakeSettings.json from the main menu by choosing CMake | Change CMake Settings. Usuń "Ninja", a następnie wpisz "V".Delete “Ninja” and type “V”. Aktywuje funkcję IntelliSense, która pozwala na dokonanie wyboru generator, który ma.This activates IntelliSense, which enables you to choose the generator you want.

  1. wybrany element buildRoot: mapuje -DCMAKE_BINARY_DIR Przełącz i określa, w którym zostanie utworzona pamięci podręcznej narzędzia CMake.buildRoot: maps to -DCMAKE_BINARY_DIR switch and specifies where the CMake cache will be created. Jeśli folder nie istnieje, zostanie utworzony.If the folder does not exist, it is created.

  2. zmienne: zawiera pary nazwa wartość, zmienne narzędzia CMake, które będą przekazywane jako -Dnazwa=wartość do narzędzia CMake.variables: contains a name-value pair of CMake variables that will get passed as -Dname=value to CMake. Instrukcje kompilacji projektu narzędzia CMake określić dodanie wszelkie zmienne bezpośrednio do pliku pamięci podręcznej narzędzia CMake, zaleca się dodanie ich w tym miejscu zamiast tego.If your CMake project build instructions specify the addition of any variables directly to the CMake cache file, it is recommended that you add them here instead. Poniższy przykład pokazuje, jak określić pary nazwa wartość:The following example shows how to specify the name-value pairs:

"variables": [
    {
      "name": "CMAKE_CXX_COMPILER",
      "value": "C:/Program Files (x86)/Microsoft Visual Studio/157/Enterprise/VC/Tools/MSVC/14.14.26428/bin/HostX86/x86/cl.exe"
    },
    {
      "name": "CMAKE_C_COMPILER",
      "value": "C:/Program Files (x86)/Microsoft Visual Studio/157/Enterprise/VC/Tools/MSVC/14.14.26428/bin/HostX86/x86/cl.exe"
    }
  ]
  1. cmakeCommandArgs: określa żadnych dodatkowych przełączników, które mają być przekazane do CMake.exe.cmakeCommandArgs: specifies any additional switches you want to pass to CMake.exe.

  2. Typ konfiguracji: Określa typ konfiguracji kompilacji dla wybranego generatora.configurationType: defines the build configuration type for the selected generator. Obecnie obsługiwane wartości to "Debug", "MinSizeRel", "Wersja" i "RelWithDebInfo".Currently supported values are "Debug", "MinSizeRel", "Release", and "RelWithDebInfo".

  3. ctestCommandArgs: Określa dodatkowe przełączniki do przekazania do narzędzia CTest podczas uruchamiania testów.ctestCommandArgs: specifies additional switches to pass to CTest when running tests.

  4. buildCommandArgs: Określa dodatkowe przełączniki do przekazania do bazowego systemu kompilacji.buildCommandArgs: specifies additional switches to pass to the underlying build system. Na przykład przekazując - v, gdy przy użyciu generatora Ninja wymusza Ninja w danych wyjściowych wiersze polecenia.For example, passing -v when using the Ninja generator forces Ninja to output command lines.

Zmienne środowiskoweEnvironment variables

CMakeSettings.json obsługuje również konsumencki zmiennych środowiskowych w dowolnej właściwości wymienionych powyżej.CMakeSettings.json also supports consuming environment variables in any of the properties mentioned above. Składnia służąca do użycia jest ${env.FOO} rozwinąć zmiennej środowiskowej % FOO %.The syntax to use is ${env.FOO} to expand the environment variable %FOO%. Masz także dostęp do wbudowanych makr, w tym pliku:You also have access to built-in macros inside this file:

  • ${workspaceRoot} — zapewnia pełną ścieżkę folderu obszaru roboczego${workspaceRoot} – provides the full path of the workspace folder
  • ${workspaceHash} — Skrót lokalizacji obszaru roboczego. przydatne podczas tworzenia Unikatowy identyfikator dla bieżącego obszaru roboczego (na przykład do użycia w ścieżkach folderów)${workspaceHash} – hash of workspace location; useful for creating a unique identifier for the current workspace (for example, to use in folder paths)
  • ${projectFile} — Pełna ścieżka pliku CMakeLists.txt głównego${projectFile} – the full path of the root CMakeLists.txt file
  • ${projectDir} — Pełna ścieżka do folderu głównego pliku CMakeLists.txt${projectDir} – the full path of the folder of the root CMakeLists.txt file
  • ${thisFile} — Pełna ścieżka pliku CMakeSettings.json${thisFile} – the full path of the CMakeSettings.json file
  • ${name} — Nazwa konfiguracji${name} – the name of the configuration
  • ${generator} — Nazwa generatora narzędzia CMake, używany w tej konfiguracji${generator} – the name of the CMake generator used in this configuration

Ninja argumenty wiersza poleceniaNinja command line arguments

W przypadku nieokreślonego obiekty docelowe kompilacji docelowej "default" (zobacz ręczne).If targets are unspecified, builds the 'default' target (see manual).

C:\Program Files (x86)\Microsoft Visual Studio\Preview\Enterprise>ninja -?
ninja: invalid option -- `-?'
usage: ninja [options] [targets...]
OpcjaOption OpisDescription
--wersji--version Drukuj ninja wersji ("1.7.1")print ninja version ("1.7.1")
-C DIR-C DIR Zmień na katalog, przed wykonaniem jakichkolwiek innych czynnościchange to DIR before doing anything else
-f pliku-f FILE Określ plik wejściowy kompilacji (default=build.ninja)specify input build file (default=build.ninja)
-j N-j N równoległe wykonywanie zadań N (domyślny = 14, pochodzące z procesorów dostępnych)run N jobs in parallel (default=14, derived from CPUs available)
-k N-k N Kontynuuj, dopóki N zadanie zakończy się niepowodzeniem (domyślny = 1)keep going until N jobs fail (default=1)
-l N-l N Nie uruchamiaj nowe zadania, jeśli średnia obciążenia jest większa niż Ndo not start new jobs if the load average is greater than N
-n-n Wysuszyć Uruchom (nie uruchamiać polecenia, ale działają tak, jak one powiodło się)dry run (don't run commands but act like they succeeded)
-v-v Pokaż wszystkie wiersze polecenia podczas tworzeniashow all command lines while building
-d tryb-d MODE Włącz debugowanie (tryby listy do użycia -d)enable debugging (use -d list to list modes)
t - narzędzie-t TOOL Uruchom subtool (Użyj -t listy do narzędzi niższego poziomu).run a subtool (use -t list to list subtools). kończy toplevel opcje; Dodatkowo flagi są przekazywane do narzędziaterminates toplevel options; further flags are passed to the tool
-w flagi-w FLAG Dostosuj ostrzeżenia (Użyj -w listy do ostrzeżenia)adjust warnings (use -w list to list warnings)

Dziedziczonych środowisk (Visual Studio 2017 w wersji 15.5)Inherited environments (Visual Studio 2017 version 15.5)

CMakeSettings.json obsługuje teraz dziedziczonych środowisk.CMakeSettings.json now supports inherited environments. Ta funkcja umożliwia (1) dziedziczą środowiska domyślnego i (2) Utwórz niestandardowe zmienne środowiskowe, które są przekazywane do CMake.exe po jego uruchomieniu.This feature enables you to (1) inherit default environments and (2) create custom environment variables that are passed to CMake.exe when it runs.

  "inheritEnvironments": [ "msvc_x64_x64" ]

W powyższym przykładzie jest taka sama jak działa wiersz polecenia programisty dla programu VS 2017 z -arch = amd64-host_arch = amd64 argumentów.The example above is the same as running the Developer Command Prompt for VS 2017 with the -arch=amd64 -host_arch=amd64 arguments.

W poniższej tabeli przedstawiono domyślne wartości i ich odpowiedniki wiersza polecenia:The following table shows the default values and their command line equivalents:

Nazwa kontekstuContext Name OpisDescription
vsdevvsdev Domyślne środowisko Visual StudioThe default Visual Studio environment
msvc_x86msvc_x86 Kompiluj przy użyciu x86 x86 narzędziaCompile for x86 using x86 tools
msvc_armmsvc_arm Kompilowanie dla ARM przy użyciu x86 narzędziaCompile for ARM using x86 tools
msvc_arm64msvc_arm64 Kompilacji dla architektury ARM64 przy użyciu x86 narzędziaCompile for ARM64 using x86 tools
msvc_x86_x64msvc_x86_x64 Kompilacji dla AMD64 przy użyciu x86 narzędziaCompile for AMD64 using x86 tools
msvc_x64_x64msvc_x64_x64 Kompilacji dla AMD64 przy użyciu narzędzi 64-bitowychCompile for AMD64 using 64-bit tools
msvc_arm_x64msvc_arm_x64 Kompilowanie dla ARM przy użyciu narzędzi 64-bitowychCompile for ARM using 64-bit tools
msvc_arm64_x64msvc_arm64_x64 Kompilacji dla architektury ARM64 przy użyciu narzędzi 64-bitowychCompile for ARM64 using 64-bit tools

Niestandardowe zmienne środowiskoweCustom environment variables

W pliku CMakeSettings.json, można zdefiniować niestandardowe zmienne środowiskowe globalnie lub na konfiguracji w środowisk właściwości.In CMakeSettings.json, you can define custom environment variables globally or per-configuration in the environments property. W poniższym przykładzie zdefiniowano jednej zmiennej globalnej, BuildDir, która jest dziedziczona przez konfiguracje debugowania x86 i x64 debugowania.The following example defines one global variable, BuildDir, which is inherited in both the x86-Debug and x64-Debug configurations. Każda konfiguracja używa zmiennej, aby określić wartość dla wybrany element buildRoot właściwości dla tej konfiguracji.Each configuration uses the variable to specify the value for the buildRoot property for that configuration. Należy zauważyć, jak korzysta z konfiguracjami inheritEnvironments właściwość, aby określić zmienną, która ma zastosowanie tylko do tej konfiguracji.Note also how each configuration uses the inheritEnvironments property to specify a variable that applies only to that configuration.

{
  // The "environments" property is an array of key value pairs of the form
  // { "EnvVar1": "Value1", "EnvVar2": "Value2" }
  "environments": [
    {
      "BuildDir": "${env.USERPROFILE}\\CMakeBuilds\\${workspaceHash}\\build",
    }
  ],

  "configurations": [
    {
      "name": "x86-Debug",
      "generator": "Ninja",
      "configurationType": "Debug",
      // Inherit the defaults for using the MSVC x86 compiler.
      "inheritEnvironments": [ "msvc_x86" ],
      "buildRoot": "${env.BuildDir}\\${name}"    },
    {
      "name": "x64-Debug",
      "generator": "Ninja",
      "configurationType": "Debug",
      // Inherit the defaults for using the MSVC x64 compiler.
      "inheritEnvironments": [ "msvc_x64" ],
      "buildRoot": "${env.BuildDir}\\${name}"
    }
  ]
}

W następnym przykładzie konfiguracja debugowania x86 definiuje wartość dla BuildDir właściwość i ta wartość zastępuje wartość ustawioną przy użyciu globalnego BuildDir właściwość tak, aby Wybrany element BuildRoot daje w wyniku D:\custom-builddir\x86-Debug.In the next example, the x86-Debug configuration defines its own value for the BuildDir property, and this value overrides the value set by the global BuildDir property so that BuildRoot evaluates to D:\custom-builddir\x86-Debug.

{
  "environments": [
    {
      "BuildDir": "${env.USERPROFILE}\\CMakeBuilds\\${workspaceHash}",
    }
  ],

  "configurations": [
    {
      "name": "x86-Debug",

      // The syntax for this property is the same as the global one above.
      "environments": [
        {
          // Replace the global property entirely.
          "BuildDir": "D:\\custom-builddir",
        }
      ],

      "generator": "Ninja",
      "configurationType": "Debug",
      "inheritEnvironments": [ "msvc_x86" ],
      // Evaluates to "D:\custom-builddir\x86-Debug"
      "buildRoot": "${env.BuildDir}\\${name}"
    },
    {
      "name": "x64-Debug",

      "generator": "Ninja",
      "configurationType": "Debug",
      "inheritEnvironments": [ "msvc_x64" ],
      // Since this configuration doesn’t modify BuildDir, it inherits
      // from the one defined globally.
      "buildRoot": "${env.BuildDir}\\${name}"
    }
  ]
}

Krok konfigurowania CMakeCMake configure step

W przypadku istotnych zmian do pliku CMakeSettings.json lub do pliku CMakeLists.txt plików, programu Visual Studio automatycznie krok konfigurowania powtórkami narzędzia CMake.When significant changes are made to the CMakeSettings.json or to CMakeLists.txt files, Visual Studio automatically reruns the CMake configure step. Jeśli krok konfiguracja zakończy się bez błędów, zbieranych informacji są dostępne w funkcji C++ IntelliSense i usług językowych również w kompilacji i debugowania operacji.If the configure step finishes without errors, the information that is collected is available in C++ IntelliSense and language services and also in build and debug operations.

Korzystając z wielu projektów CMake taką samą nazwę konfiguracji narzędzia CMake (na przykład x86-Debug), wszystkie z nich są konfigurowane i wbudowane (folder główny własne kompilacji) po wybraniu tej konfiguracji.When multiple CMake projects use the same CMake configuration name (for example, x86-Debug), all of them are configured and built (in their own build root folder) when that configuration is selected. Można debugować cele ze wszystkich projektów CMake, które uczestniczą w tej konfiguracji narzędzia CMake.You can debug the targets from all of the CMake projects that participate in that CMake configuration.

Kompilacji CMake tylko element menuCMake Build Only menu item

Aby ograniczyć kompilacji i debugowania sesji podzestaw projektów w obszarze roboczym, Utwórz nową konfigurację z unikatową nazwą w pliku CMakeSettings.json i dotyczą tylko tych projektów.To limit builds and debug sessions to a subset of the projects in the workspace, create a new configuration with a unique name in the CMakeSettings.json file and apply it to those projects only. Po wybraniu tej konfiguracji IntelliSense i kompilacja i debugowanie poleceń są włączone tylko dla tych określonych projektów.When that configuration is selected, the IntelliSense and build and debug commands are enabled only for those specified projects.

Rozwiązywanie problemów z błędami pamięci podręcznej narzędzia CMakeTroubleshooting CMake cache errors

Jeśli potrzebujesz więcej informacji na temat stanu pamięci podręcznej narzędzia CMake, aby zdiagnozować problem, otwórz CMake menu głównego lub CMakeLists.txt menu kontekstowego w Eksploratora rozwiązańdo uruchamiania jednego z następujących poleceń:If you need more information about the state of the CMake cache to diagnose a problem, open the CMake main menu or the CMakeLists.txt context menu in Solution Explorer to run one of these commands:

  • Wyświetlanie pamięci podręcznej otwiera plik CMakeCache.txt wobec folderu głównego kompilacji w edytorze.View Cache opens the CMakeCache.txt file from the build root folder in the editor. (Wszystkie zmiany wprowadzone w tym miejscu CMakeCache.txt są wyczyszczone, jeśli czyszczenia pamięci podręcznej.(Any edits you make here to CMakeCache.txt are wiped out if you clean the cache. Aby wprowadzić zmiany, które są zachowywane po czyszczeniu pamięci podręcznej, zobacz CMake ustawienia i konfiguracje niestandardowe we wcześniejszej części tego artykułu.)To make changes that persist after the cache is cleaned, see CMake settings and custom configurations earlier in this article.)

  • Otwórz Folder pamięci podręcznej zostanie otwarte okno Eksploratora do folderu głównego kompilacji.Open Cache Folder opens an Explorer window to the build root folder.

  • Czyszczenie pamięci podręcznej usuwa folder główny kompilacji CMake dalej skonfigurowania uruchamia krok z czystą pamięci podręcznej.Clean Cache deletes the build root folder so that the next CMake configure step starts from a clean cache.

  • Generuj pamięć podręczną wymusza krok Wygeneruj, aby uruchomić, nawet jeśli program Visual Studio traktuje środowiska aktualne.Generate Cache forces the generate step to run even if Visual Studio considers the environment up-to-date.

Visual Studio 2017 w wersji 15.7 lub nowszej: generowanie pamięci podręcznej automatycznego można wyłączyć w narzędzia | Opcje | Narzędzie CMake | Ogólne okna dialogowego.Visual Studio 2017 version 15.7 and later: Automatic cache generation can be disabled in the Tools | Options | CMake | General dialog.

Pojedynczy plik kompilacjiSingle File Compilation

Visual Studio 2017 w wersji 15.7 lub nowszej: Aby utworzyć pojedynczy plik projektu narzędzia CMake, kliknij prawym przyciskiem myszy plik w Eksploratora rozwiązań i wybierz polecenie skompilować.Visual Studio 2017 version 15.7 and later: To build a single file in a CMake project, right-click on the file in Solution Explorer and choose Compile. Można także utworzyć plik który jest obecnie otwarty w edytorze za pomocą menu głównego narzędzia CMake:You can also build the file that is currently open in the editor by using the main CMake menu:

Narzędzie CMake pojedynczy plik kompilacji

Wykonywania CMake z wiersza poleceniaRun CMake from the command line

Po zainstalowaniu narzędzia CMake z Instalatora programu Visual Studio, można uruchomić go z wiersza polecenia, wykonując następujące czynności:If you have installed CMake from the Visual Studio Installer, you can run it from the command line by following these steps:

  1. Uruchom odpowiedni vsdevcmd.bat — x86/x64 64.Run the appropriate vsdevcmd.bat (x86/x64). Zobacz tworzenia w wierszu polecenia Aby uzyskać więcej informacji.See Building on the Command Line for more information.
  2. Przejdź do folderu wyjściowego.Switch to your output folder.
  3. Wykonywania CMake kompilacji/skonfigurować aplikację.Run CMake to build/configure your app.