Konfigurowanie i kompilowanie przy użyciu ustawień wstępnych narzędzia CMake w programie Visual Studio

Narzędzie CMake obsługuje dwa pliki, które umożliwiają użytkownikom określanie typowych opcji konfiguracji, kompilacji i testowania oraz udostępnianie ich innym: CMakePresets.json i CMakeUserPresets.json. Użyj tych plików, aby dysk CMake w programach Visual Studio i Visual Studio Code w potoku ciągłej integracji i z wiersza polecenia.

CMakePresets.json program służy do zapisywania kompilacji obejmujących cały projekt. CMakeUserPresets.json program jest przeznaczony dla deweloperów do zapisywania własnych kompilacji lokalnych. Oba pliki są obsługiwane w programie Visual Studio 2019 w wersji 16.10 lub nowszej.

Ten artykuł zawiera informacje o CMakePresets.json integracji z programem Visual Studio. Oto przydatne linki:

• Aby uzyskać więcej informacji na temat formatu CMakePresets.jsonprogramu , zobacz oficjalną dokumentację narzędzia CMake.
• Aby uzyskać więcej informacji na temat map dostawców firmy Microsoft i rozszerzania makr, zobacz CMakePresets.json mapy dostawców firmy Microsoft.CMakeUserPresets.json
• Aby uzyskać więcej informacji na temat używania w programie Visual Studio Code, zobacz Konfigurowanie i kompilowanie przy użyciu CMakePresets.json ustawień wstępnych narzędzia CMake.

Zalecamy CMakePresets.json alternatywę dla CMakeSettings.jsonelementu . Program Visual Studio nigdy nie odczytuje z obu CMakePresets.json i CMakeSettings.json jednocześnie. Aby włączyć lub wyłączyć CMakePresets.json integrację w programie Visual Studio, zobacz Włączanie CMakePresets.json w programie Visual Studio 2019.

Obsługiwane narzędzia CMake i CMakePresets.json wersje

Obsługiwane CMakePresets.json wersje schematów zależą CMakeUserPresets.json od używanej wersji programu Visual Studio:

• Program Visual Studio 2019 w wersji 16.10 lub nowszej obsługuje schemat w wersji 2 i 3.
• Program Visual Studio 2022 w wersji 17.4 (wersja zapoznawcza 1) dodaje obsługę schematu w wersji 4.
• Program Visual Studio 2022 w wersji 17.5 (wersja zapoznawcza 1) dodaje obsługę schematu w wersji 5.

Wersję można zaktualizować, zmieniając "version" pole w obiekcie głównym. Aby uzyskać przykład i więcej informacji, zobacz CMakePresets.json format.

Narzędzie CMake w wersji 3.20 lub nowszej jest wymagane podczas wywoływania narzędzia CMake z CMakePresets.json poziomu wiersza polecenia. Jednak program Visual Studio odczytuje CMakePresets.json i ocenia siebie i CMakeUserPresets.json nie wywołuje narzędzia CMake bezpośrednio z opcją --preset . Dlatego narzędzie CMake w wersji 3.20 lub nowszej nie jest ściśle wymagane podczas kompilowania w CMakePresets.json programie Visual Studio.

Zalecamy używanie co najmniej narzędzia CMake w wersji 3.14 lub nowszej.

Włączanie CMakePresets.json integracji w programie Visual Studio

CMakePresets.json integracja nie jest domyślnie włączona w programie Visual Studio. Można ją włączyć w obszarze Narzędzia>Opcje>ogólne narzędzia CMake:>

Ten ekran jest osiągany z menu programu Visual Studio 2022: Narzędzia > Opcje > narzędzia CMake > Ogólne. Opcja znajduje się w sekcji CMake configure file (Konfigurowanie pliku narzędzia CMake).

Ważne

Zamknij i otwórz ponownie folder w programie Visual Studio, aby aktywować integrację.

W niektórych starszych wersjach programu Visual Studio opcje>narzędzi>CMake>General mają tylko jedną opcję włączenia CMakePresets.json integracji:

Poniższa tabela wskazuje, kiedy CMakePresets.json jest używana zamiast CMakeSettings.json do obsługi konfiguracji narzędzia CMake i kompilacji w programach Visual Studio 2022 i Visual Studio 2019 w wersji 16.10 lub nowszej. Jeśli nie ma pliku konfiguracji, są używane domyślne ustawienia wstępne konfiguracji.

W tabeli opcja "Opcje narzędzi>włączone" oznacza użycie CMakePresets.json do konfigurowania, kompilowania i testowania narzędzia CMake jest wybierana w obszarze Narzędzia>Opcje>CMake>Ogólne.

Pliki konfiguracji	Opcje narzędzi > są wyłączone	Opcje narzędzi > są włączone
Brak pliku konfiguracji	CMakeSettings.json	CMakePresets.json
CMakeSettings.json prezentować	CMakeSettings.json	CMakePresets.json
CMakePresets.json prezentować	CMakePresets.json	CMakePresets.json
Oba pliki konfiguracji są obecne	CMakePresets.json	CMakePresets.json

Modyfikowanie automatycznej konfiguracji i powiadomień pamięci podręcznej

Domyślnie program Visual Studio automatycznie wywołuje za każdym razem, gdy aktywny system docelowy configure lub Skonfiguruj zmiany ustawień wstępnych. To zachowanie można zmodyfikować, wybierając pozycję Nigdy nie uruchamiaj kroku konfiguruj automatycznie w obszarze Narzędzia>Opcje>ogólne narzędzia.> Możesz również wyłączyć wszystkie powiadomienia pamięci podręcznej narzędzia CMake (złote słupki) przez wyczyszczenie powiadomień pokaż pamięć podręczną narzędzia CMake.

Domyślne konfigurowanie ustawień wstępnych

Jeśli żaden plik CMakeUserPresets.json lub plik nie CMakePresets.json istnieje lub CMakePresets.json CMakeUserPresets.json jest nieprawidłowy, program Visual Studio powraca do następujących domyślnych ustawień wstępnych konfiguracji:

Przykład dla systemu Windows

{
  "name": "windows-default",
  "displayName": "Windows x64 Debug",
  "description": "Sets Ninja generator, compilers, x64 architecture, build and install directory, debug build type",
  "generator": "Ninja",
  "binaryDir": "${sourceDir}/out/build/${presetName}",
  "architecture": {
    "value": "x64",
    "strategy": "external"
  },
  "cacheVariables": {
    "CMAKE_BUILD_TYPE": "Debug",
    "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}"
  },
  "vendor": {
    "microsoft.com/VisualStudioSettings/CMake/1.0": {
      "hostOS": [ "Windows" ]
    }
  }
},

Przykład dla systemu Linux

{
  "name": "linux-default",
  "displayName": "Linux Debug",
  "description": "Sets Ninja generator, compilers, build and install directory, debug build type",
  "generator": "Ninja",
  "binaryDir": "${sourceDir}/out/build/${presetName}",
  "cacheVariables": {
    "CMAKE_BUILD_TYPE": "Debug",
    "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}"
  },
  "vendor": {
    "microsoft.com/VisualStudioSettings/CMake/1.0": {
      "hostOS": [ "Linux" ]
    },
    "microsoft.com/VisualStudioRemoteSettings/CMake/1.0": {
      "sourceDir": "$env{HOME}/.vs/$ms{projectDirName}"
   }
  }
}

Jeśli spróbujesz otworzyć lub zmodyfikować CMakePresets.json plik, który nie istnieje, program Visual Studio automatycznie utworzy CMakePresets.json plik z domyślnym ustawieniem Konfiguruj ustawienia wstępne w katalogu głównym projektu.

Konfigurowanie i kompilowanie

Na pasku narzędzi programu Visual Studio znajdują się listy rozwijane systemów docelowych, Konfigurowanie ustawień wstępnych i Ustawienia wstępne kompilacji po CMakePresets.json włączeniu integracji:

Wybieranie systemu docelowego

Lista rozwijana po lewej stronie wskazuje aktywny system docelowy. Jest to system, w którym wywoływano narzędzie CMake w celu skonfigurowania i skompilowania projektu. Ta lista rozwijana zawiera maszynę lokalną, wszystkie połączenia SSH w Menedżer połączeń według nazwy hosta oraz wszystkie instalacje Podsystem Windows dla systemu Linux (WSL), które można znaleźć w programie Visual Studio:

Lista rozwijana zawiera kilka wpisów, w tym Komputer lokalny, adres IP 192.168.0.5, WSL: ubuntu2004, WSL: debian i Zarządzanie połączeniami.

W powyższym przykładzie:

• 192.168.0.5 jest zdalnym systemem Linux, który został dodany do Menedżer połączeń.
• Ubuntu2004 i debian to instalacje WSL.

Wybierz pozycję Zarządzaj połączeniami, aby otworzyć Menedżer połączeń.

Wybieranie ustawienia wstępnego konfigurowania

Lista rozwijana w środku wskazuje aktywne konfigurowanie ustawień wstępnych. configurePreset Jest to wartość używana podczas wywoływania narzędzia CMake w celu wygenerowania systemu kompilacji projektu. Ta lista rozwijana zawiera związek nieukrywanych ustawień wstępnych zdefiniowanych w elementach CMakePresets.json i CMakeUserPresets.json.

Program Visual Studio używa wartości hostOS w mapie dostawcy ustawień programu Microsoft Visual Studio, aby ukryć ustawienia wstępne, które nie mają zastosowania do aktywnego systemu docelowego. Aby uzyskać więcej informacji, zobacz wpis w hostOS tabeli w obszarze Mapa dostawcy ustawień programu Visual Studio.

Wybierz pozycję Zarządzaj konfiguracjami , aby otworzyć CMakePresets.json plik znajdujący się w katalogu głównym projektu. CMakePresets.json zostanie utworzony, jeśli jeszcze nie istnieje.

Wybieranie ustawienia wstępnego kompilacji

Lista rozwijana po prawej stronie wskazuje aktywne ustawienie wstępne kompilacji. buildPreset Jest to wartość używana podczas wywoływania narzędzia CMake w celu skompilowania projektu. Ta lista rozwijana zawiera związek nieukrytych ustawień wstępnych kompilacji zdefiniowanych w elementach CMakePresets.json i CMakeUserPresets.json.

Wszystkie ustawienia wstępne kompilacji są wymagane do określenia skojarzonej configurePreset wartości. Program Visual Studio ukrywa ustawienia wstępne kompilacji, które nie mają zastosowania do aktywnej konfiguracji ustawień wstępnych. Aby uzyskać więcej informacji, zobacz listę ustawień wstępnych kompilacji.

Jeśli nie ma ustawień wstępnych kompilacji skojarzonych z aktywnym ustawieniem konfiguracji, program Visual Studio wyświetla domyślne ustawienie wstępne kompilacji. Domyślne ustawienie wstępne kompilacji jest równoważne przekazywaniu cmake --build bez innych argumentów z wiersza polecenia.

Konfiguruj

Program Visual Studio automatycznie próbuje skonfigurować projekt, gdy wykryje, że pamięć podręczna CMake jest nieaktualna. Aby ręcznie wywołać konfigurację, wybierz pozycję Project Configure project-name (Konfiguruj>< nazwę> projektu) z menu głównego. Jest on taki sam jak w przypadku uruchamiania cmake --preset <configurePreset> z wiersza polecenia, gdzie <configurePreset> jest nazwą aktywnej konfiguracji ustawień wstępnych.

Aby wyłączyć automatyczne generowanie pamięci podręcznej, zobacz Automatyczne konfigurowanie i powiadomienia pamięci podręcznej.

Kompilacja

Aby skompilować cały projekt, wybierz pozycję Kompiluj>wszystko z menu głównego. Jest on taki sam jak w przypadku uruchamiania cmake --build --preset <buildPreset> z wiersza polecenia, gdzie <buildPreset> jest nazwą aktywnego ustawienia wstępnego kompilacji.

Aby utworzyć pojedynczy element docelowy, przejdź do widoku obiektów docelowych narzędzia CMake w Eksplorator rozwiązań. Następnie kliknij prawym przyciskiem myszy dowolny element docelowy i wybierz polecenie Kompiluj z menu skrótów.

Uwaga

Program Visual Studio 2019 nie obsługuje buildPresets.targets opcji kompilowania podzestawu elementów docelowych określonych w programie CMakePresets.json.

Uruchamianie narzędzia CTest

CMakePresets.json program obsługuje dwie opcje menu w programie Visual Studio 2019:

• Test Uruchom testy>CTest dla < projektu> wywołuje CTest i uruchamia wszystkie testy skojarzone z aktywnym ustawieniem wstępnie skonfigurowanym i wstępnie kompilacji, bez innych argumentów przekazanych do narzędzia CTest.
• Test Run Test>Preset for <configurePreset> rozwija się, aby wyświetlić wszystkie ustawienia wstępne testu skojarzone z aktywnym ustawieniem wstępnie skonfigurowanym. Wybranie pojedynczego ustawienia wstępnego testu jest takie samo jak uruchamianie ctest --preset <testPreset> z wiersza polecenia, gdzie <testPreset> jest nazwą wybranego ustawienia wstępnego testu. Ta opcja jest niedostępna, jeśli nie zdefiniowano ustawień wstępnych testów dla aktywnej konfiguracji ustawienia wstępnego.

W programie Visual Studio 2019 Eksplorator testów nie jest zintegrowany z CMakePresets.jsonprogramem .

Dodawanie nowych ustawień wstępnych

W programie Visual Studio 2019 wszystkie polecenia i szablony wstępne modyfikują element CMakePresets.json. Nowe ustawienia wstępne na poziomie użytkownika można dodać bezpośrednio, edytując CMakeUserPresets.jsonpolecenie .

Użyj ukośnika () do/ ścieżek w systemach CMakePresets.json i CMakeUserPresets.json.

Dodaj nowe ustawienia wstępne konfiguracji

Aby dodać nowy element Configure Preset to CMakePresets.json, w Eksplorator rozwiązań kliknij prawym przyciskiem myszy CMakePresets.json pozycję Widok folderu i wybierz polecenie Dodaj konfigurację z menu skrótów. Zostanie wyświetlone okno dialogowe konfigurowania szablonu Ustawienia wstępne:

Wybierz szablon Debugowanie systemu Windows x64, aby skonfigurować w systemach Windows. Wybierz szablon Debugowanie systemu Linux, aby skonfigurować w systemach WSL i zdalnych systemach Linux. Aby uzyskać więcej informacji na temat edytowania CMakePresets.json, zobacz Edytowanie ustawień wstępnych.

Wybrany szablon jest dodawany do CMakePresets.json elementu , jeśli istnieje. W przeciwnym razie szablon zostanie skopiowany do nowego CMakePresets.json pliku.

Dodawanie nowych ustawień wstępnych kompilacji i ustawień wstępnych testów

Program Visual Studio 2019 nie oferuje szablonów dla nowych ustawień wstępnych kompilacji i ustawień wstępnych testów. Ustawienia wstępne kompilacji i ustawienia wstępne testów można dodać bezpośrednio do edycji CMakePresets.json. Aby uzyskać więcej informacji, zobacz listę ustawień wstępnych kompilacji, listę ustawień wstępnych testów lub przykładowy CMakePresets.json plik.

Edytowanie ustawień wstępnych

Oficjalna dokumentacja narzędzia CMake jest najlepszym zasobem do edytowania ustawień wstępnych, ustawień wstępnych kompilacji i ustawień wstępnych testów. Poniższe informacje są podzbiorem dokumentacji narzędzia CMake, która jest szczególnie istotna dla deweloperów programu Visual Studio.

Wybieranie kompilatorów

Kompilatory języka C i C++ można ustawić przy użyciu elementów cacheVariables.CMAKE_C_COMPILER i cacheVariables.CMAKE_CXX_COMPILER w konfiguracji ustawień wstępnych. Jest on odpowiednikiem przekazywania -D CMAKE_C_COMPILER=<value> i -D CMAKE_CXX_COMPILER=<value> do narzędzia CMake z wiersza polecenia. Aby uzyskać więcej informacji, zobacz CMAKE_<LANG>_COMPILER.

Skorzystaj z poniższych przykładów, aby skompilować program cl.exe Visual Studio i clang-cl.exe z niego. Narzędzia C++ Clang dla składników systemu Windows muszą być zainstalowane, aby można je było skompilować za pomocą clang-clprogramu .

Skompiluj za pomocą polecenia cl.exe:

"cacheVariables": {
  "CMAKE_BUILD_TYPE": "Debug",
  "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}",
  "CMAKE_C_COMPILER": "cl",
  "CMAKE_CXX_COMPILER": "cl"
},

Skompiluj za pomocą polecenia clang:

"cacheVariables": {
  "CMAKE_BUILD_TYPE": "Debug",
  "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}",
  "CMAKE_C_COMPILER": "clang-cl",
  "CMAKE_CXX_COMPILER": "clang-cl"
},

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

Jeśli używasz Visual Studio 16 2019 generatora lub Visual Studio 17 2022 jako generatora, możesz użyć toolset ustawienia Konfiguruj ustawienie wstępne, aby określić ClangCL zestaw narzędzi:

"cacheVariables": {
  "CMAKE_BUILD_TYPE": "Debug",
  "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}",
},

"toolset": "ClangCL",

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

Aby uzyskać więcej informacji na temat generatorów obsługujących specyfikację toolset , zobacz CMAKE_GENERATOR_TOOLSET dokumentację narzędzia CMake.

Ważne

W programie Visual Studio 2019 należy jawnie określić tryb funkcji IntelliSense języka Clang podczas kompilowania za pomocą clang polecenia lub clang-cl.

Aby odtworzyć te kompilacje poza programem Visual Studio, zobacz Uruchamianie narzędzia CMake z wiersza polecenia lub potoku ciągłej integracji.

Aby budować w systemie Linux lub bez zestawu narzędzi Visual C++, określ nazwę kompilatora w PATH wystąpieniu lub zmienną środowiskową, która ocenia pełną ścieżkę kompilatora. Pełne ścieżki są odradzane, aby plik mógł pozostać udostępniony. Ustawienie wstępne kompilacji z biblioteką GCC w wersji 8 może wyglądać następująco:

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

Kompilatory można również ustawić za pomocą pliku łańcucha narzędzi CMake. Pliki łańcucha narzędzi można ustawić za pomocą cacheVariables.CMAKE_TOOLCHAIN_FILEelementu , który jest odpowiednikiem przekazywania -D CMAKE_TOOLCHAIN_FILE=<value> do narzędzia CMake z wiersza polecenia. Plik łańcucha narzędzi CMake jest najczęściej używany do kompilowania krzyżowego. Aby uzyskać więcej informacji na temat tworzenia plików łańcucha narzędzi CMake, zobacz Łańcuchy narzędzi CMake.

Wybieranie generatora

Szablony Ustawień wstępnych systemu Windows i Linux określają ninja jako generator domyślny. Inne typowe generatory to generatory programu Visual Studio w systemach Windows i Unix Makefile w systemach Linux i macOS. Możesz określić nowy generator z generator opcją w skonfiguruj ustawienie wstępne. Jest to równoważne przekazywaniu -G do narzędzia CMake z wiersza polecenia.

Ustaw architecture.strategy i toolset.strategy na set wartość podczas kompilowania za pomocą generatora programu Visual Studio. Aby uzyskać więcej informacji, zobacz Generatory CMake.

Wybierz typ konfiguracji

Typ konfiguracji (Debug lub Release) można ustawić dla generatorów pojedynczej konfiguracji przy użyciu polecenia cacheVariables.CMAKE_BUILD_TYPE. Jest to równoważne przekazywaniu -D CMAKE_BUILD_TYPE=<value> do narzędzia CMake z wiersza polecenia. Aby uzyskać więcej informacji, zobacz CMAKE_BUILD_TYPE.

Wybieranie architektury docelowej i hosta podczas kompilowania przy użyciu zestawu narzędzi Visual C++

Architekturę docelową (x64, Win32, ARM64 lub ARM) można ustawić przy użyciu polecenia architecture.value. Jest to równoważne przekazywaniu -A do narzędzia CMake z wiersza polecenia. Aby uzyskać więcej informacji, zobacz Wybór platformy.

Uwaga

Obecnie generatory programu Visual Studio oczekują składni Win32 i generatorów wiersza polecenia (takich jak Ninja) oczekują składni x86 podczas kompilowania dla architektury x86.

Architekturę hosta (x64 lub x86) i zestaw narzędzi można ustawić przy użyciu polecenia toolset.value. Jest to równoważne przekazywaniu -T do narzędzia CMake z wiersza polecenia. Aby uzyskać więcej informacji, zobacz Wybór zestawu narzędzi.

Wartości architecture.strategy i toolset.strategy informują CMake, jak obsługiwać pola architektury i zestawu narzędzi. set oznacza, że CMake ustawia odpowiednią wartość i external oznacza, że CMake nie ustawi odpowiedniej wartości.

Zalecamy używanie z set generatorami IDE, takimi jak Generator programu Visual Studio. Używaj z external generatorami wiersza polecenia, takimi jak Ninja. Te wartości umożliwiają dostawcom, takich jak Visual Studio dostarczanie wymaganego środowiska przed wywołaniem narzędzia CMake. Aby uzyskać więcej informacji na temat pól architektury i zestawu narzędzi, zobacz listę konfigurowanie ustawień wstępnych.

Jeśli nie chcesz używać środowiska źródłowego, możesz ustawić wartość architecture.strategy external i architecture.value na unspecified. Przydatne może być nie źródło środowiska z jednego z następujących powodów:

• Używasz zestawu narzędzi innego niż MSVC.
• Używasz niestandardowego łańcucha narzędzi, takiego jak w scenariuszach osadzonych.
• Do kompilowania nie jest potrzebne określone środowisko.

Aby uzyskać pełną listę generatorów IDE obsługujących pole architektury, zobacz CMAKE_GENERATOR_PLATFORM. Aby uzyskać pełną listę generatorów IDE obsługujących pole zestawu narzędzi, zobacz CMAKE_GENERATOR_TOOLSET.

Użyj poniższych przykładów, aby zastosować architekturę ARM64 z generatorem Ninja lub kierować do systemu Win32 (x86) przy użyciu generatora programu Visual Studio 16 2019:

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

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

Ustawianie i odwoływania się do zmiennych środowiskowych

Zmienne środowiskowe można ustawić przy użyciu mapy środowiska. Zmienne środowiskowe są dziedziczone przez inherits pole, ale można je zastąpić tak, jak chcesz.

Środowisko ustawień wstępnych jest związkiem własnego środowiska i środowiska ze wszystkich jego rodziców. Jeśli wiele inherits ustawień wstępnych udostępnia wartości powodujące konflikt dla tej samej zmiennej, preferowane jest wcześniejsze ustawienie wstępne na inherits liście. Można usunąć ustawienie zmiennej dziedziczonej z innego ustawienia wstępnego, ustawiając ją na null.

Zmienne środowiskowe ustawione w ustawieniu wstępnie skonfigurowanym automatycznie przepływają również do skojarzonych ustawień wstępnych kompilacji i ustawień wstępnych testów, chyba że inheritConfigureEnvironment ustawiono wartość false. Aby uzyskać więcej informacji, zobacz listę konfigurowanie ustawień wstępnych.

Zmienne środowiskowe można odwoływać się przy użyciu składni $env{<variable-name>} i $penv{<variable-name>} . Aby uzyskać więcej informacji, zobacz Rozszerzenie makr.

Konfigurowanie funkcji IntelliSense dla kompilatora krzyżowego

Domyślnie program Visual Studio używa trybu IntelliSense zgodnego z określoną architekturą zestawu narzędzi i architekturą docelową. Jeśli kompilujesz krzyżowo, może być konieczne ręczne określenie prawidłowego trybu funkcji IntelliSense przy użyciu intelliSenseMode opcji na mapie dostawcy ustawień programu Visual Studio. Aby uzyskać więcej informacji, zobacz wpis w intelliSenseMode tabeli w obszarze Mapa dostawcy ustawień programu Visual Studio.

Konfigurowanie i kompilowanie systemu zdalnego lub Podsystem Windows dla systemu Linux

Dzięki CMakePresets.json obsłudze programu Visual Studio można łatwo skonfigurować i skompilować projekt w systemach Windows, WSL i zdalnych. Kroki konfigurowania i kompilowania projektu w systemie Windows, systemie zdalnym lub WSL są takie same. Jednak kilka zachowań jest specyficznych dla programowania zdalnego.

${sourceDir} zachowanie w scenariuszach kopiowania zdalnego

W lokalnych scenariuszach (w tym WSL1) ${sourceDir} ocenia ścieżkę do katalogu źródłowego projektu otwartego w programie Visual Studio. W scenariuszach ${sourceDir} kopiowania zdalnego oblicza ścieżkę do katalogu źródłowego projektu w systemie docelowym, a nie katalog źródłowy projektu na komputerze lokalnym.

Wartość sourceDir w mapie dostawcy ustawień zdalnych programu Visual Studio określa katalog źródłowy projektu w systemie docelowym (domyślnie ).$env{HOME}/.vs/$ms{projectDirName} Aby uzyskać więcej informacji, zobacz wpis w sourceDir tabeli w obszarze Mapa dostawcy ustawień programu Visual Studio.

Folder lokalny dla danych wyjściowych zdalnych

Scenariusze kopiowania zdalnego wymagają katalogu lokalnego do skopiowania niektórych plików zdalnych, takich jak pliki odpowiedzi interfejsu API plików CMake lub pliki kompilacji, jeśli copyBuildOutput na mapie dostawcy ustawień zdalnych programu Visual Studio ustawiono wartość true. Te pliki są automatycznie kopiowane do <local-source-directory>/out/<remote-connection-ID>/build/${presetName}pliku .

Wywoływanie tego samego ustawienia konfiguracji w systemach Windows i WSL1

Jeśli spróbujesz użyć tego samego ustawienia konfiguracji ustawień w systemach Windows i WSL1, zostanie wyświetlony błąd. Systemy Windows i WSL1 używają systemu plików Windows, więc narzędzie CMake spróbuje użyć tego samego katalogu wyjściowego (binaryDir) dla drzew kompilacji systemu Windows i WSL1.

Jeśli chcesz użyć tego samego ustawienia konfiguracji ustawień wstępnych zarówno z systemem Windows, jak i zestawem narzędzi WSL1, utwórz drugą opcję Konfiguruj ustawienie wstępne dziedziczone z oryginalnego ustawienia wstępnego i określa nową binaryDir wartość. W poniższym przykładzie windows-preset można go użyć w systemie Windows i base-preset można go użyć w systemie WSL1:

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

Uwaga

W programie Visual Studio 2019 obsługiwany jest tylko zestaw narzędzi WSL1. To zachowanie będzie widoczne w dowolnym momencie wywoływania configure zarówno w systemie Windows, jak i WSL.

Włączanie integracji z programem vcpkg

Narzędzie Vcpkg ułatwia zarządzanie bibliotekami C i C++ w systemach Windows, Linux i macOS. Aby umożliwić integrację narzędzia vcpkg (vcpkg.cmake), należy przekazać do narzędzia CMake. Aby uzyskać więcej informacji, zobacz dokumentację narzędzia vcpkg.

Program Visual Studio nie przekazuje już pliku łańcucha narzędzi vcpkg do narzędzia CMake automatycznie po CMakePresets.json włączeniu integracji. Ta zmiana eliminuje zachowanie specyficzne dla programu Visual Studio i zapewnia możliwość odtworzenia kompilacji z poziomu wiersza polecenia.

Zamiast tego ustaw ścieżkę na vcpkg.cmake przy użyciu zmiennej środowiskowej VCPKG_ROOT w pliku CMakePresets.json:

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

VCPKG_ROOT powinna być ustawiona na katalog główny instalacji programu vcpkg. Aby uzyskać więcej informacji, zobacz zmienne środowiskowe vcpkg.

Jeśli używasz już pliku łańcucha narzędzi CMake i chcesz włączyć integrację narzędzia vcpkg, zobacz Korzystanie z wielu plików łańcucha narzędzi. Postępuj zgodnie z tymi instrukcjami, aby użyć zewnętrznego pliku łańcucha narzędzi z projektem przy użyciu narzędzia vcpkg.

Podstawianie zmiennych w i launch.vs.jsontasks.vs.json

CMakePresets.json obsługuje podstawianie zmiennych w systemach launch.vs.json i tasks.vs.json. Oto kilka zagadnień:

• Zmienne środowiskowe ustawione w aktywnej konfiguracji Ustawienia wstępne automatycznie przepływają do launch.vs.json i tasks.vs.json konfiguracji. Możesz usunąć ustawienie poszczególnych zmiennych środowiskowych w launch.vs.json programie i tasks.vs.json przez ustawienie ich na null. Poniższy przykład ustawia zmienną na null w launch.vs.jsonpliku DEBUG_LOGGING_LEVEL : "env": { "DEBUG_LOGGING_LEVEL": null }.

• Wartości klucza ustawione w aktywnym ustawieniach konfiguracji są dostępne do użycia w launch.vs.json programie i tasks.vs.json ze składnią ${cmake.<KEY-NAME>}. Na przykład użyj polecenia ${cmake.binaryDir} , aby odwołać się do katalogu wyjściowego aktywnego ustawienia konfiguracji ustawień wstępnych.

• Poszczególne zmienne środowiskowe ustawione na mapie środowiska aktywnego Ustawienia wstępne konfiguracji są dostępne do użycia w launch.vs.json pliku i tasks.vs.json za pomocą składni ${env.<VARIABLE-NAME>}.

Zaktualizuj pliki launch.vs.json i task.vs.json do składni referencyjnej CMakePresets.json CMakeSettings.json zamiast składni. Makra odwołujące się do starej CMakeSettings.json składni, gdy CMakePresets.json jest aktywnym plikiem konfiguracji, są przeznaczone do wycofania w przyszłej wersji. Na przykład odwołaj się do katalogu wyjściowego aktywnej konfiguracji ustawienia wstępnego ${cmake.binaryDir} zamiast ${cmake.buildRoot}, ponieważ CMakePresets.json używa binaryDir składni.

Rozwiązywanie problemów

Jeśli wszystko nie działa zgodnie z oczekiwaniami, możesz spróbować wykonać kilka kroków rozwiązywania problemów.

Jeśli element CMakePresets.json lub CMakeUserPresets.json jest nieprawidłowy, program Visual Studio powróci do domyślnego zachowania i wyświetli tylko domyślne ustawienia wstępne konfiguracji. Funkcja IntelliSense w programie Visual Studio może pomóc w przechwyceniu wielu z tych błędów JSON, ale nie będzie wiadomo, czy odwołujesz się do ustawień wstępnych z inherits nieprawidłową nazwą.configurePreset

Aby sprawdzić, czy pliki wstępne są prawidłowe, uruchom polecenie cmake --list-presets z poziomu wiersza polecenia w katalogu głównym katalogu projektu. (Wymagany jest program CMake 3.20 lub nowszy). Jeśli dowolny plik jest nieprawidłowy, zostanie wyświetlony następujący błąd:

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

Inne kroki rozwiązywania problemów obejmują:

• Usuń pamięć podręczną i ponownie skonfiguruj projekt (CMake: Usuwanie pamięci podręcznej i Konfigurowanie <projektu>nazwa> projektu).
• Zamknij i otwórz ponownie folder w programie Visual Studio (Plik>Zamknij folder).
• .vs Usuń folder w katalogu głównym projektu.

Jeśli zidentyfikowano problem, najlepszym sposobem raportowania jest wybranie przycisku Wyślij opinię w prawym górnym rogu programu Visual Studio.

Włączanie rejestrowania dla połączeń zdalnych

Rejestrowanie połączeń zdalnych można włączyć, jeśli masz problemy z nawiązywaniem połączenia lub kopiowaniem plików do systemu zdalnego. Aby uzyskać więcej informacji, zobacz Rejestrowanie połączeń zdalnych.

Włączanie narzędzia AddressSanitizer dla systemów Windows i Linux

Program Visual Studio obsługuje narzędzie AddressSanitizer (ASAN), narzędzie do wykrywania błędów pamięci środowiska uruchomieniowego języka C i C++ dla programowania w systemach Windows i Linux. Opcja addressSanitizerEnabled w programie CMakeSettings.json włącza element AddressSanitizer. CMakePresets.json nie obsługuje tego zachowania.

Zamiast tego włącz i wyłącz funkcję AddressSanitizer, ustawiając samodzielnie wymagane flagi kompilatora i konsolidatora. Ustawienie ich powoduje usunięcie zachowania specyficznego dla programu Visual Studio i gwarantuje, że ten sam CMakePresets.json plik może odtworzyć kompilację z wiersza polecenia.

Aby włączyć lub wyłączyć element AddressSanitizer dla elementu docelowego, możesz dodać następujący przykład CMakeLists.txt :

option(ASAN_ENABLED "Build this target with AddressSanitizer" ON)

if(ASAN_ENABLED)
  if(MSVC)
    target_compile_options(<target> PUBLIC /fsanitize=address)
  else()
    target_compile_options(<target> PUBLIC -fsanitize=address <additional-options>)
    target_link_options(<target> PUBLIC -fsanitize=address)
  endif()
endif()

Część <additional-options> zawiera listę innych flag kompilacji, takich jak "-fno-omit-frame-pointer". Aby uzyskać więcej informacji na temat narzędzia AddressSanitizer dla systemu Linux, zobacz Using AddressSanitizer (Używanie narzędzia AddressSanitizer). Aby uzyskać więcej informacji na temat używania narzędzia AddressSanitizer z MSVC, zobacz Use AddressSanitizer from a developer command prompt (Używanie narzędzia AddressSanitizer z wiersza polecenia dewelopera).

Przekaż flagi środowiska uruchomieniowego do elementu AddressSanitizer przy użyciu pola w pliku ASAN_OPTIONS launch.vs.json. ASAN_OPTIONS wartość domyślna to detect_leaks=0 , gdy nie określono żadnych innych opcji środowiska uruchomieniowego, ponieważ narzędzie LeakSanitizer nie jest obsługiwane w programie Visual Studio.

Uruchamianie narzędzia CMake z wiersza polecenia lub potoku ciągłej integracji

Możesz użyć tych samych CMakePresets.json plików i CMakeUserPresets.json , aby wywołać narzędzie CMake w programie Visual Studio i z poziomu wiersza polecenia. Dokumentacja narzędzia CMake i narzędzia CTest to najlepsze zasoby dotyczące wywoływania narzędzi CMake i CTest za pomocą polecenia --preset. Wymagany jest program CMake w wersji 3.20 lub nowszej.

Określanie źródła środowiska podczas kompilowania za pomocą generatorów wiersza polecenia w systemie Windows

Użytkownik musi skonfigurować środowisko przed wywołaniem narzędzia CMake podczas kompilowania za pomocą generatora wiersza polecenia. Jeśli tworzysz za pomocą narzędzia Ninja i zestawu narzędzi Visual C++ w systemie Windows, ustaw środowisko przed wywołaniem narzędzia CMake w celu wygenerowania systemu kompilacji. Można to zrobić, wywołując vcvarsall.bat argument .architecture Argument architecture określa host i architekturę docelową do użycia. Aby uzyskać więcej informacji, zobacz vcvarsall składnię. Jeśli korzystasz z systemu Linux lub Windows za pomocą generatora programu Visual Studio, nie musisz wykonywać tego kroku.

Jest to ten sam krok, który należy wykonać w programie Visual Studio, gdy środowisko IDE wywołuje narzędzie CMake. Program Visual Studio analizuje aktywną konfigurację ustawień wstępnych dla hosta i architektury docelowej określonej przez toolset i architecture. Program Visual Studio następnie źródła określonego środowiska z programu vcvarsall.bat. Podczas kompilowania z poziomu wiersza polecenia systemu Windows za pomocą narzędzia Ninja musisz wykonać ten krok samodzielnie.

vcvarsall.bat program jest instalowany przy użyciu narzędzi Build Tools for Visual Studio. Domyślnie vcvarsall.bat program jest instalowany w programie C:\Program Files (x86)\Microsoft Visual Studio\2019\<edition>\VC\Auxiliary\Build. Jeśli często używasz przepływu pracy wiersza polecenia, możesz go dodać vcvarsall.bat PATH .

Przykładowy przepływ pracy wiersza polecenia

Poniższe polecenia umożliwiają skonfigurowanie i skompilowanie projektu CMake, który używa narzędzia Ninja do kierowania arm64 za pomocą narzędzi kompilacji x64. Wymagany jest program CMake w wersji 3.20 lub nowszej. Uruchom następujące polecenia z katalogu, w którym CMakePresets.json znajduje się plik:

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

Przykładowy CMakePresets.json plik

Plik CMakePresets.json w polu2d-lite zawiera przykłady konfigurowania ustawień wstępnych, ustawień wstępnych kompilacji i ustawień wstępnych testów. Aby uzyskać więcej informacji na temat tego przykładu, zobacz prezentację Wprowadzenie do CMakePresets.json. W projekcie DirectXTK można zobaczyć inny przykład, który pokazuje wiele obiektów docelowych kompilacji w jego configurePresets sekcji.

Następne kroki

Dowiedz się więcej na temat konfigurowania i debugowania projektów CMake w programie Visual Studio:

Projekty CMake w programie Visual Studio
Dostosowywanie ustawień kompilacji narzędzia CMake
Konfigurowanie sesji debugowania narzędzia CMake
Dokumentacja wstępnie zdefiniowanej konfiguracji narzędzia CMake