Konfigurowanie projektu CMake systemu Linux w programie Visual Studio

Artykuł
06/16/2023

Obsługa systemu Linux jest dostępna w programie Visual Studio 2017 lub nowszym. Aby wyświetlić dokumentację tych wersji, ustaw listę rozwijaną Wersja znajdującą się powyżej spisu treści na Visual Studio 2017 lub Visual Studio 2019.

W tym temacie opisano sposób dodawania konfiguracji systemu Linux do projektu CMake przeznaczonego dla zdalnego systemu Linux lub Podsystem Windows dla systemu Linux (WSL). Kontynuuje serię, która rozpoczęła się od tworzenia projektu CMake systemu Linux w programie Visual Studio. Jeśli używasz programu MSBuild, zobacz Konfigurowanie projektu MSBuild systemu Linux w programie Visual Studio

Dodawanie konfiguracji systemu Linux

Konfiguracja może służyć do kierowania różnych platform (Windows, WSL, systemu zdalnego) z tym samym kodem źródłowym. Konfiguracja służy również do ustawiania kompilatorów, przekazywania zmiennych środowiskowych i dostosowywania sposobu wywoływania narzędzia CMake. Plik CMakeSettings.json określa niektóre lub wszystkie właściwości wymienione w temacie Dostosowywanie ustawień narzędzia CMake oraz inne właściwości kontrolujące ustawienia kompilacji na zdalnej maszynie z systemem Linux.

Aby zmienić domyślne ustawienia narzędzia CMake w programie Visual Studio 2017, wybierz pozycję CMake Zmień ustawienia >narzędzia CMake>CMakeLists.txtz menu głównego. Możesz też kliknąć prawym przyciskiem myszy CMakeLists.txt w Eksplorator rozwiązań i wybrać polecenie Zmień ustawienia narzędzia CMake. Następnie program Visual Studio tworzy nowy plik CMakeSettings.json w głównym folderze projektu. Aby wprowadzić zmiany, otwórz plik i zmodyfikuj go bezpośrednio. Aby uzyskać więcej informacji, zobacz Dostosowywanie ustawień narzędzia CMake.

Domyślna konfiguracja Linux-Debug w programie Visual Studio 2017 (i Visual Studio 2019 w wersji 16.0) wygląda następująco:

{
  "configurations": [
    {
      "name": "Linux-Debug",
      "generator": "Unix Makefiles",
      "remoteMachineName": "${defaultRemoteMachineName}",
      "configurationType": "Debug",
      "remoteCMakeListsRoot": "/var/tmp/src/${workspaceHash}/${name}",
      "cmakeExecutable": "/usr/local/bin/cmake",
      "buildRoot": "${env.USERPROFILE}\\CMakeBuilds\\${workspaceHash}\\build\\${name}",
      "installRoot": "${env.USERPROFILE}\\CMakeBuilds\\${workspaceHash}\\install\\${name}",
      "remoteBuildRoot": "/var/tmp/build/${workspaceHash}/build/${name}",
      "remoteInstallRoot": "/var/tmp/build/${workspaceHash}/install/${name}",
      "remoteCopySources": true,
      "remoteCopySourcesOutputVerbosity": "Normal",
      "remoteCopySourcesConcurrentCopies": "10",
      "remoteCopySourcesMethod": "rsync",
      "remoteCopySourcesExclusionList": [
        ".vs",
        ".git"
      ],
      "rsyncCommandArgs": "-t --delete --delete-excluded",
      "remoteCopyBuildOutput": false,
      "cmakeCommandArgs": "",
      "buildCommandArgs": "",
      "ctestCommandArgs": "",
      "inheritEnvironments": [
        "linux_x64"
      ]
    }
  ]
}

Aby zmienić domyślne ustawienia narzędzia CMake w programie Visual Studio 2019 lub nowszym, na głównym pasku narzędzi otwórz listę rozwijaną Konfiguracja i wybierz pozycję Zarządzaj konfiguracjami.

Zrzut ekranu przedstawiający konfiguracje zarządzania narzędziem CMake wyróżnione na liście rozwijanej Konfiguracja.

To polecenie otwiera Edytor ustawień narzędzia CMake, którego można użyć do edytowania pliku CMakeSettings.json w głównym folderze projektu. Możesz również otworzyć plik za pomocą edytora JSON, klikając przycisk Edytuj kod JSON w prawym górnym rogu okna dialogowego Ustawienia narzędzia CMake . Aby uzyskać więcej informacji, zobacz Dostosowywanie ustawień narzędzia CMake.

Domyślna konfiguracja Linux-Debug w programie Visual Studio 2019 w wersji 16.1 lub nowszej wygląda następująco:

{
  "configurations": [
    {
      "name": "Linux-GCC-Debug",
      "generator": "Ninja",
      "configurationType": "Debug",
      "cmakeExecutable": "cmake",
      "remoteCopySourcesExclusionList": [ ".vs", ".git", "out" ],
      "cmakeCommandArgs": "",
      "buildCommandArgs": "",
      "ctestCommandArgs": "",
      "inheritEnvironments": [ "linux_x64" ],
      "remoteMachineName": "${defaultRemoteMachineName}",
      "remoteCMakeListsRoot": "$HOME/.vs/${projectDirName}/${workspaceHash}/src",
      "remoteBuildRoot": "$HOME/.vs/${projectDirName}/${workspaceHash}/out/build/${name}",
      "remoteInstallRoot": "$HOME/.vs/${projectDirName}/${workspaceHash}/out/install/${name}",
      "remoteCopySources": true,
      "rsyncCommandArgs": "-t --delete --delete-excluded",
      "remoteCopyBuildOutput": false,
      "remoteCopySourcesMethod": "rsync",
      "variables": []
    }
  ]
}

W programie Visual Studio 2019 w wersji 16.6 lub nowszej ninja jest domyślnym generatorem konfiguracji przeznaczonych dla systemu zdalnego lub systemu WSL, w przeciwieństwie do plików makefile systemu Unix. Aby uzyskać więcej informacji, zobacz ten wpis na blogu zespołu języka C++.

Aby uzyskać więcej informacji na temat tych ustawień, zobacz CMakeSettings.json reference (Dokumentacja pliku CMakeSettings.json).

Podczas tworzenia kompilacji:

Jeśli system zdalny jest przeznaczony dla systemu zdalnego, program Visual Studio wybiera pierwszy system zdalny na liście w obszarze Narzędzia>Opcje>międzyplatformowe>Menedżer połączeń domyślnie dla zdalnych obiektów docelowych.
Jeśli nie zostaną znalezione żadne połączenia zdalne, zostanie wyświetlony monit o utworzenie połączenia. Aby uzyskać więcej informacji, zobacz Nawiązywanie połączenia ze zdalnym komputerem z systemem Linux.

Wybierz element docelowy systemu Linux

Po otwarciu folderu projektu CMake program Visual Studio analizuje plik CMakeLists.txt i określa element docelowy systemu Windows x86-Debug. Aby wybrać system zdalnego systemu Linux, zmienisz ustawienia projektu na podstawie kompilatora systemu Linux. Jeśli na przykład używasz GCC w systemie Linux i kompilujesz informacje o debugowaniu, wybierz pozycję Linux-GCC-Debug lub Linux-GCC-Release.

Jeśli określisz zdalny element docelowy systemu Linux, źródło zostanie skopiowane do systemu zdalnego.

Po wybraniu elementu docelowego narzędzie CMake jest uruchamiane automatycznie w systemie Linux w celu wygenerowania pamięci podręcznej CMake dla projektu:

Zrzut ekranu programu Visual Studio przedstawiający dane wyjściowe funkcji Generowanie pamięci podręcznej CMake w systemie Linux.

Podsystem Windows dla systemu Linux docelowa

Jeśli celujesz w Podsystem Windows dla systemu Linux (WSL), nie musisz dodawać połączenia zdalnego.

Aby wybrać docelową usługę WSL, wybierz pozycję Zarządzaj konfiguracjami na liście rozwijanej konfiguracji na głównym pasku narzędzi:

Lista rozwijana Konfiguracji narzędzia CMake z listą rozwijaną Zarządzaj konfiguracjami wybranymi

Zostanie wyświetlone okno CMakeSettings.json .

Okno dialogowe ustawień narzędzia CMake z wyróżnionym przyciskiem plus, który dodaje wybraną konfigurację, czyli Linux-GCC-debug.

Naciśnij przycisk Dodaj konfigurację (zielony przycisk +), a następnie wybierz pozycję Linux-GCC-Debug lub Linux-GCC-Release , jeśli używasz GCC. Użyj wariantów języka Clang, jeśli używasz zestawu narzędzi Clang/LLVM. Naciśnij pozycję Wybierz , a następnie naciśnij klawisze Ctrl+S , aby zapisać konfigurację.

Visual Studio 2019 w wersji 16.1 W przypadku docelowej bazy danych WSL program Visual Studio nie musi kopiować plików źródłowych i obsługiwać dwie synchroniczne kopie drzewa kompilacji, ponieważ kompilator w systemie Linux ma bezpośredni dostęp do plików źródłowych w zainstalowanym systemie plików systemu Windows.

IntelliSense

Dokładna funkcja IntelliSense języka C++ wymaga dostępu do nagłówków języka C++, do których odwołuje się pliki źródłowe języka C++. Program Visual Studio automatycznie używa nagłówków, do których odwołuje się projekt CMake z systemu Linux do systemu Windows, aby zapewnić pełną wierność funkcji IntelliSense. Aby uzyskać więcej informacji, zobacz IntelliSense dla nagłówków zdalnych.

Ustawienie ustawień regionalnych

Ustawienia języka programu Visual Studio nie są propagowane do obiektów docelowych systemu Linux, ponieważ program Visual Studio nie zarządza zainstalowanymi pakietami ani nie konfiguruje ich. Komunikaty wyświetlane w oknie Dane wyjściowe, takie jak błędy kompilacji, są wyświetlane przy użyciu języka i ustawień regionalnych elementu docelowego systemu Linux. Należy skonfigurować docelowe obiekty docelowe systemu Linux dla żądanych ustawień regionalnych.

Więcej ustawień

Użyj następujących ustawień, aby uruchamiać polecenia w systemie Linux przed i po utworzeniu oraz przed generowaniem narzędzia CMake. Wartości mogą być dowolnym poleceniem prawidłowym w systemie zdalnym. Dane wyjściowe są przesyłane potokami z powrotem do programu Visual Studio.

{
      "remotePrebuildCommand": "",
      "remotePreGenerateCommand": "",
      "remotePostbuildCommand": "",
}

Następne kroki

Konfigurowanie sesji debugowania narzędzia CMake

Zobacz też

Praca z właściwościami projektu
Dostosowywanie ustawień narzędzia CMake
Dokumentacja wstępnie zdefiniowanej konfiguracji narzędzia CMake

Udostępnij za pośrednictwem