Samouczek: instalowanie i używanie pakietów za pomocą narzędzia CMake

W tym samouczku pokazano, jak utworzyć program "Hello World" w języku C++, który używa biblioteki za pomocą fmt narzędzia CMake i narzędzia vcpkg. Zainstalujesz zależności, skonfigurujesz, skompilujesz i uruchomisz prostą aplikację.

Wymagania wstępne

Terminal
Kompilator języka C++
CMake
Usługa Git

Uwaga

W przypadku użytkowników systemu Windows kompilator MSVC (Microsoft Visual C++) programu Visual Studio jest wymaganym kompilatorem do programowania w języku C++.

1 — Konfigurowanie programu vcpkg

Klonowanie repozytorium

Pierwszym krokiem jest sklonowanie repozytorium vcpkg z usługi GitHub. Repozytorium zawiera skrypty w celu uzyskania pliku wykonywalnego vcpkg i rejestru wyselekcjonowanych bibliotek open source obsługiwanych przez społeczność programu vcpkg. Aby to zrobić, uruchom polecenie:
```
git clone https://github.com/microsoft/vcpkg.git
```
Rejestr wyselekcjonowanych vcpkg to zestaw ponad 2000 bibliotek typu open source. Te biblioteki zostały zweryfikowane przez potoki ciągłej integracji vcpkg do współpracy. Chociaż repozytorium vcpkg nie zawiera kodu źródłowego dla tych bibliotek, przechowuje przepisy i metadane do kompilowania i instalowania ich w systemie.
Uruchamianie skryptu bootstrap

Po sklonowaniu repozytorium vcpkg przejdź do vcpkg katalogu i wykonaj skrypt bootstrap:
```
cd vcpkg && bootstrap-vcpkg.bat
```
```
cd vcpkg; .\bootstrap-vcpkg.bat
```
```
cd vcpkg && ./bootstrap-vcpkg.sh
```
Skrypt bootstrap wykonuje testy wymagań wstępnych i pobiera plik wykonywalny vcpkg.

I już! Narzędzie vcpkg jest skonfigurowane i gotowe do użycia.

2 — Konfigurowanie projektu

Skonfiguruj zmienną VCPKG_ROOT środowiskową.
```
export VCPKG_ROOT=/path/to/vcpkg
export PATH=$VCPKG_ROOT:$PATH
```
Uwaga

Ustawienie zmiennych środowiskowych przy użyciu export polecenia wpływa tylko na bieżącą sesję powłoki. Aby zmienić tę zmianę export na stałe między sesjami, dodaj polecenie do skryptu profilu powłoki (np. ~/.bashrc lub ~/.zshrc).
```
set "VCPKG_ROOT=C:\path\to\vcpkg"
set PATH=%VCPKG_ROOT%;%PATH%
```
Uwaga

Ustawienie zmiennych środowiskowych w ten sposób wpływa tylko na bieżącą sesję terminalu. Aby wprowadzić te zmiany na stałe we wszystkich sesjach, ustaw je za pomocą panelu Zmienne środowiskowe systemu Windows.
```
$env:VCPKG_ROOT = "C:\path\to\vcpkg"
$env:PATH = "$env:VCPKG_ROOT;$env:PATH"
```
Uwaga

Ustawienie zmiennych środowiskowych w ten sposób wpływa tylko na bieżącą sesję terminalu. Aby wprowadzić te zmiany na stałe we wszystkich sesjach, ustaw je za pomocą panelu Zmienne środowiskowe systemu Windows.
Ustawienie VCPKG_ROOT informuje vcpkg, gdzie znajduje się wystąpienie vcpkg. Dodanie go w celu PATH zapewnia, że można uruchamiać polecenia vcpkg bezpośrednio z poziomu powłoki.
Utwórz katalog projektu.
```
mkdir helloworld && cd helloworld
```

3 — Dodawanie zależności i plików projektu

Utwórz plik manifestu i dodaj fmt zależność.

Najpierw utwórz plik manifestu (vcpkg.json) w katalogu projektu, uruchamiając vcpkg new polecenie z poziomu helloworld katalogu:
```
vcpkg new --application
```
Następnie dodaj fmt zależność:
```
vcpkg add port fmt
```
Powinien vcpkg.json wyglądać następująco:
```
{
    "dependencies": [
        "fmt"
    ]
}
```
Jest to plik manifestu. Narzędzie vcpkg odczytuje plik manifestu, aby dowiedzieć się, jakie zależności mają być instalowane i integrowane z programem CMake w celu zapewnienia zależności wymaganych przez projekt.

Plik domyślny vcpkg-configuration.json wprowadza ograniczenia linii bazowej , określając minimalne wersje zależności, których powinien używać projekt. Modyfikowanie tego pliku wykracza poza zakres tego samouczka, ale odgrywa kluczową rolę w definiowaniu ograniczeń wersji dla zależności projektu. W związku z tym, mimo że nie jest to absolutnie konieczne w tym samouczku, dobrym rozwiązaniem jest dodanie vcpkg-configuration.json kontroli źródła w celu zapewnienia spójności wersji w różnych środowiskach deweloperskich.
Utwórz pliki projektu.

CMakeLists.txt Utwórz plik z następującą zawartością:
```
cmake_minimum_required(VERSION 3.10)

project(HelloWorld)

find_package(fmt CONFIG REQUIRED)

add_executable(HelloWorld helloworld.cpp)

target_link_libraries(HelloWorld PRIVATE fmt::fmt)
```
Teraz podzielmy działanie każdego wiersza w CMakeLists.txt pliku:
- cmake_minimum_required(VERSION 3.10): określa, że minimalna wersja narzędzia CMake wymagana do skompilowania projektu to 3.10. Jeśli wersja narzędzia CMake zainstalowana w systemie jest niższa niż ta, zostanie wygenerowany błąd.
- project(HelloWorld): Ustawia nazwę projektu na "HelloWorld".
- find_package(fmt CONFIG REQUIRED): szuka fmt biblioteki przy użyciu pliku konfiguracji narzędzia CMake. Słowo REQUIRED kluczowe gwarantuje wygenerowanie błędu, jeśli pakiet nie zostanie znaleziony.
- add_executable(HelloWorld helloworld.cpp): dodaje element docelowy wykonywalny o nazwie "HelloWorld", skompilowany z pliku helloworld.cppźródłowego .
- target_link_libraries(HelloWorld PRIVATE fmt::fmt): określa, że HelloWorld plik wykonywalny powinien łączyć się z biblioteką fmt . Słowo PRIVATE kluczowe wskazuje, że fmt jest wymagane tylko do kompilowania HelloWorld i nie powinno być propagowane do innych projektów zależnych.
helloworld.cpp Utwórz plik z następującą zawartością:
```
#include <fmt/core.h>

int main()
{
    fmt::print("Hello World!\n");
    return 0;
}
```
W tym helloworld.cpp pliku <fmt/core.h> nagłówek jest dołączany do korzystania z fmt biblioteki. Następnie main() funkcja wywołuje fmt::print() polecenie , aby wyświetlić komunikat "Hello World!" do konsoli.

4 — Kompilowanie i uruchamianie projektu

Uruchamianie konfiguracji narzędzia CMake

Narzędzie CMake może automatycznie łączyć biblioteki zainstalowane przez narzędzie vcpkg, gdy CMAKE_TOOLCHAIN_FILE jest ustawione na użycie niestandardowego łańcucha narzędzi vcpkg. Może to być skompilowane przy użyciu plików ustawień wstępnych narzędzia CMake.

Utwórz następujące pliki w helloworld katalogu:

CMakePresets.json
```
{
  "version": 2,
  "configurePresets": [
    {
      "name": "vcpkg",
      "generator": "Ninja",
      "binaryDir": "${sourceDir}/build",
      "cacheVariables": {
        "CMAKE_TOOLCHAIN_FILE": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake"
      }
    }
  ]
}
```
CMakeUserPresets.json
```
{
  "version": 2,
  "configurePresets": [
    {
      "name": "default",
      "inherits": "vcpkg",
      "environment": {
        "VCPKG_ROOT": "<path to vcpkg>"
      }
    }
  ]
}
```
Plik CMakePresets.json zawiera jedno ustawienie wstępne o nazwie "vcpkg", które ustawia zmienną CMAKE_TOOLCHAIN_FILE . Plik CMakeUserPresets.json ustawia zmienną VCPKG_ROOT środowiskową, aby wskazywała ścieżkę bezwzględną zawierającą lokalną instalację programu vcpkg. Zaleca się, aby nie zaewidencjonować CMakeUserPresets.json systemów kontroli wersji.

Na koniec skonfiguruj kompilację przy użyciu narzędzia CMake:
```
cmake --preset=default
```
Kompilowanie projektu

Uruchom:
```
cmake --build build
```
Uruchamianie aplikacji

Na koniec uruchom plik wykonywalny, aby zobaczyć aplikację w działaniu:
```
./build/HelloWorld

Hello World!
```
```
.\build\HelloWorld.exe

Hello World!
```

Następne kroki

Sprzężenie zwrotne

Czy ta strona była pomocna?

Last updated on 2024-09-26