Konfigurowanie i kompilowanie za pomocą ustawień wstępnych narzędzia CMake w programie Visual Studio

  • Artykuł
  • Czas czytania: 19 min

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:

Zalecamy CMakePresets.json alternatywę dla CMakeSettings.jsonelementu . 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:

Zrzut ekranu przedstawiający pole wyboru umożliwiające włączenie pliku CMakePresets.json na stronie Ogólne narzędzia okna dialogowego Opcje narzędzi w programie Visual Studio 2022 w wersji 17.1.

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:

Zrzut ekranu przedstawiający pole wyboru umożliwiające włączenie pliku CMakePresets.json na stronie Ogólne narzędzia okna dialogowego Opcje narzędzi w programie Visual Studio 2019.

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.jsonCMakeUserPresets.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:

Zrzut ekranu przedstawiający listy rozwijane systemu docelowego.

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:

Zrzut ekranu przedstawiający wybrane opcje z listy rozwijanej systemu docelowego.

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.jsonpolecenie .

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:

Zrzut ekranu przedstawiający okno dialogowe dodawania ustawienia wstępnego do pliku J S O N.

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-clprogramu , 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_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 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.jsonpliku :

"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.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 aktywnym ustawieniu Skonfiguruj ustawienie wstępne automatycznie przepływają do launch.vs.json konfiguracji i tasks.vs.json . Nie można ustawić poszczególnych zmiennych środowiskowych w launch.vs.json programie i tasks.vs.json przez ustawienie ich na nullwartość . W poniższym przykładzie zmienna jest ustawiana na null w launch.vs.jsonpliku DEBUG_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 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 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 i tasks.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_OPTIONSlaunch.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:

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