Konfigurowanie i kompilowanie za pomocą 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, kompilowania i testowania oraz udostępniania ich innym osobom: CMakePresets.json
i CMakeUserPresets.json
. Użyj tych plików, aby dysk CMake w programie Visual Studio i Visual Studio Code, w potoku ciągłej integracji (CI) i z wiersza polecenia.
CMakePresets.json
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.json
programu , zobacz oficjalną dokumentację narzędzia CMake. - Aby uzyskać więcej informacji na temat map dostawcy firmy Microsoft i rozszerzania makr, zobacz
CMakePresets.json
mapy dostawców firmy Microsoft.CMakeUserPresets.json
- Aby uzyskać więcej informacji na temat używania
CMakePresets.json
w Visual Studio Code, zobacz Konfigurowanie i kompilowanie za pomocą ustawień wstępnych narzędzia CMake.
Zalecamy CMakePresets.json
alternatywę dla CMakeSettings.json
elementu . Program Visual Studio nigdy nie odczytuje z obu CMakePresets.json
tych elementów 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 schematu i CMakeUserPresets.json
zależą 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 2) dodaje obsługę schematu w wersji 4 i 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 w przypadku wywoływania narzędzia CMake z CMakePresets.json
poziomu wiersza polecenia. Jednak program Visual Studio odczytuje CMakePresets.json
i ocenia sam 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>narzędzia CMake>Ogólne:
Ważne
Zamknij i otwórz ponownie folder w programie Visual Studio, aby aktywować integrację.
W niektórych starszych wersjach programu Visual Studioopcje>narzędzi>CMake>Ogólne 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 plik konfiguracji nie istnieje, są używane domyślne ustawienia wstępne konfiguracji.
W tabeli opcja "Opcje narzędzi> włączone" oznacza użycie pliku CMakePresets.json, aby skonfigurować, skompilować i przetestować narzędzie CMake jest zaznaczone wobszarzeNarzędzia> Opcje> narzędziaCMake> General.
Pliki konfiguracji | Opcje narzędzi > są wyłączone | Opcje narzędzi > są włączone |
---|---|---|
Brak pliku konfiguracji | CMakeSettings.json |
CMakePresets.json |
CMakeSettings.json Obecny |
CMakeSettings.json |
CMakePresets.json |
CMakePresets.json Obecny |
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, aby automatycznie skonfigurować krok w obszarze Narzędzia>Opcje>narzędzia CMake>Ogólne. Możesz również wyłączyć wszystkie powiadomienia pamięci podręcznej CMake (złote paski), usuwając wyczyszczenie powiadomień pokaż pamięć podręczną CMake.
Domyślne konfigurowanie ustawień wstępnych
Jeśli żaden plik lub CMakeUserPresets.json
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:
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
Program Visual Studio udostępnia listy rozwijane dla systemów docelowych, konfigurowanie ustawień wstępnych i tworzenie ustawień wstępnych po CMakePresets.json
włączeniu integracji:
Wybierz system docelowy
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:
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 nieukrytych ustawień wstępnych zdefiniowanych w elementach CMakePresets.json
i CMakeUserPresets.json
.
Program Visual Studio używa wartości hostOS
na 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 aktywnego ustawienia wstępnego konfigurowania. Aby uzyskać więcej informacji, zobacz listę ustawień wstępnych kompilacji.
Jeśli nie ma ustawień wstępnych kompilacji skojarzonych z aktywnym Ustawieniem wstępnym 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
żadnych innych argumentów z wiersza polecenia.
Konfigurowanie
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ę Projekt>Konfiguruj <nazwę> projektu z menu głównego. Jest on taki sam jak w cmake --preset <configurePreset>
wierszu polecenia, gdzie <configurePreset>
jest nazwą aktywnego ustawienia wstępnego konfigurowania.
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 cmake --build --preset <buildPreset>
wierszu 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 tworzenia 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<nazwy projektu> wywołuje metodę CTest i uruchamia wszystkie testy skojarzone z aktywnym ustawieniem Konfigurowanie ustawień wstępnych i Ustawień wstępnych kompilacji, bez innych argumentów przekazanych do narzędzia CTest.
- Test>Uruchom ustawienie wstępne testu dla <ustawienia 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 uruchomienie
ctest --preset <testPreset>
z wiersza polecenia, gdzie<testPreset>
jest nazwą wybranego ustawienia wstępnego testu. Ta opcja jest niedostępna, jeśli dla aktywnego ustawienia wstępnego konfiguracji nie zdefiniowano ustawień wstępnych testu.
W programie Visual Studio 2019 Eksplorator testów nie jest zintegrowany z programem CMakePresets.json
.
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.json
polecenie .
Użyj ukośnika (/
) dla ścieżek w systemach CMakePresets.json
i CMakeUserPresets.json
.
Dodawanie nowych ustawień wstępnych konfigurowania
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 ustawień wstępnych:
Wybierz szablon Debugowanie systemu Windows x64 , aby skonfigurować go 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 to podzbiór 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 konfigurowanie ustawień wstępnych. Jest to odpowiednik 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ć elementy z programem cl.exe
Visual Studio i clang-cl.exe
z programu . Aby można było kompilować za pomocą clang-cl
programu , należy zainstalować narzędzia C++ Clang dla składników systemu Windows.
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 generatora Visual Studio 16 2019
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 Clang IntelliSense 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 kompilować w systemie Linux lub bez zestawu narzędzi Visual C++, określ nazwę kompilatora w PATH
wystąpieniu lub zmienną środowiskową, która daje w wyniku pełną ścieżkę kompilatora. Nie zaleca się używania pełnych ścieżek, dzięki czemu plik może pozostać udostępniony. Ustawienie wstępne, które jest kompilowane przy użyciu biblioteki 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"
},
Można również ustawić kompilatory za pomocą pliku łańcucha narzędzi CMake. Pliki łańcucha narzędzi można ustawić za pomocą cacheVariables.CMAKE_TOOLCHAIN_FILE
elementu , 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 CMake toolchains (Łańcuchy narzędzi CMake).
Wybieranie generatora
Szablony Ustawień wstępnych dla systemów Windows i Linux określają ninja jako domyślny generator. 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 opcją generator
w skonfiguruj ustawienie wstępne. Jest to równoważne przekazywaniu -G
do narzędzia CMake z wiersza polecenia.
Ustaw architecture.strategy
elementy 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
Można ustawić typ konfiguracji (Debug
lub Release
) dla generatorów z jedną konfiguracją 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 architektury 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ą, że składnia Win32 i generatory wiersza polecenia (na przykład 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 Program Visual Studio, dostarczenie 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ć parametr architecture.strategy
na external
i architecture.value
na unspecified
. Może się okazać, że warto nie pozyskiwać ś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 kompilacji 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, które obsługują pole zestawu narzędzi, zobacz CMAKE_GENERATOR_TOOLSET
.
Skorzystaj z 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ływanie 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 przesłonić w taki sposób, 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 zapewnia 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 Konfiguruj ustawienie wstępne również automatycznie przepływają do skojarzonych ustawień wstępnych kompilacji i ustawień wstępnych testów, chyba że inheritConfigureEnvironment
jest ustawiona 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 architektury docelowej. Jeśli kompilujesz krzyżowo, może być konieczne ręczne określenie prawidłowego trybu 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 w systemie zdalnym lub Podsystem Windows dla systemu Linux
Dzięki CMakePresets.json
obsłudze w programie 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 zdalnego programowania.
${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 program oblicza ścieżkę do katalogu źródłowego projektu w systemie docelowym, a nie do katalogu źródłowego projektu na komputerze lokalnym.
Wartość sourceDir
w mapie dostawcy ustawień zdalnych programu Visual Studio określa katalog źródłowy projektu w systemie docelowym (wartość domyślna to $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 jest ustawiona wartość true
. Te pliki są automatycznie kopiowane do programu <local-source-directory>/out/<remote-connection-ID>/build/${presetName}
.
Wywoływanie tego samego ustawienia konfiguracji ustawień 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
) zarówno dla drzew kompilacji systemu Windows, jak i WSL1.
Jeśli chcesz użyć tego samego ustawienia konfiguracji ustawienia wstępnego zarówno z systemem Windows, jak i zestawu narzędzi WSL1, utwórz drugi skonfiguruj 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, należy przekazać plik łańcucha narzędzi (vcpkg.cmake
) 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
, używając zmiennej środowiskowej VCPKG_ROOT
w CMakePresets.json
pliku :
"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 programu vcpkg.
Jeśli używasz już pliku łańcucha narzędzi CMake i chcesz włączyć integrację narzędzia vcpkg, zobacz Używanie 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.json
tasks.vs.json
CMakePresets.json
obsługuje podstawianie zmiennych w systemach launch.vs.json
i tasks.vs.json
. Oto kilka zagadnień:
Zmienne środowiskowe ustawione w aktywnym ustawieniu Skonfiguruj ustawienie wstępne automatycznie przepływają do
launch.vs.json
konfiguracji itasks.vs.json
. Nie można ustawić poszczególnych zmiennych środowiskowych wlaunch.vs.json
programie itasks.vs.json
przez ustawienie ich nanull
wartość . W poniższym przykładzie zmienna jest ustawiana nanull
wlaunch.vs.json
plikuDEBUG_LOGGING_LEVEL
:"env": { "DEBUG_LOGGING_LEVEL": null }
.Wartości klucza ustawione w aktywnym ustawieniach wstępnych są dostępne do użycia w
launch.vs.json
programie itasks.vs.json
ze składnią${cmake.<KEY-NAME>}
. Na przykład użyj polecenia${cmake.binaryDir}
, aby odwołać się do katalogu wyjściowego aktywnej konfiguracji ustawienia wstępnego.Poszczególne zmienne środowiskowe ustawione na mapie środowiska aktywnego ustawienia wstępnego konfiguracji są dostępne do użycia w
launch.vs.json
programie itasks.vs.json
za pomocą składni${env.<VARIABLE-NAME>}
.
Zaktualizuj pliki launch.vs.json
i task.vs.json
tak, aby odwoły CMakePresets.json
się do składni zamiast CMakeSettings.json
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 aktywnego ustawienia wstępnego ${cmake.binaryDir}
konfiguracji 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 pokaże tylko domyślne ustawienia wstępne. Funkcja IntelliSense programu 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 ustawienia wstępnego 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 którykolwiek z plików 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 skonfiguruj ponownie projekt (CMake: Usuwanie pamięci podręcznej iKonfigurowanie <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 na jego zgłoszenie 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 łączeniem 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), wykrywacz błędów pamięci środowiska uruchomieniowego języka C i C++ na potrzeby programowania w systemach Windows i Linux. Opcja addressSanitizerEnabled
w programie CMakeSettings.json
włącza funkcję AddressSanitizer. CMakePresets.json
nie obsługuje tego zachowania.
Zamiast tego włącz i wyłącz element 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 programem 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ędzi CMake i CTest to najlepsze zasoby do 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 w kompilacji za pomocą generatora wiersza polecenia. Jeśli kompilujesz przy użyciu 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 architekturę hosta i docelową do użycia. Aby uzyskać więcej informacji, zobacz vcvarsall
składnię. W przypadku kompilacji w systemie Linux lub w systemie Windows przy użyciu generatora programu Visual Studio nie musisz wykonywać tego kroku.
Jest to ten sam krok, który program Visual Studio wykonuje, 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 elementy 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 należy wykonać ten krok samodzielnie.
vcvarsall.bat
program jest instalowany za pomocą 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 dodać vcvarsall.bat
element do PATH
polecenia .
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 pliku CMakePresets.json. Inny przykład można zobaczyć w projekcie DirectXTK , który pokazuje wiele obiektów docelowych kompilacji w jego configurePresets
sekcji.
Następne kroki
Dowiedz się więcej o konfigurowaniu i debugowaniu projektów CMake w programie Visual Studio: