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

Artykuł
05/01/2024

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 main.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 main.cpp): dodaje element docelowy wykonywalny o nazwie "HelloWorld", skompilowany z pliku main.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.
main.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 main.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

Aby umożliwić systemowi projektu CMake rozpoznawanie bibliotek języka C++ udostępnianych przez narzędzie vcpkg, należy podać vcpkg.cmake plik łańcucha narzędzi. Aby to zautomatyzować, utwórz CMakePresets.json plik w katalogu "helloworld" o następującej zawartości:
```
{
  "version": 2,
  "configurePresets": [
    {
      "name": "default",
      "generator": "Ninja",
      "binaryDir": "${sourceDir}/build",
      "cacheVariables": {
        "CMAKE_TOOLCHAIN_FILE": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake"
      }
    }
  ]
}
```
Ten CMakePresets.json plik zawiera jedno ustawienie wstępne "domyślne" dla narzędzia CMake i ustawia zmienną CMAKE_TOOLCHAIN_FILE . Narzędzie CMAKE_TOOLCHAIN_FILE umożliwia systemowi projektu CMake rozpoznawanie bibliotek języka C++ udostępnianych przez narzędzie vcpkg. Dodanie narzędzia CMakePresets.json automatyzuje proces określania łańcucha narzędzi podczas uruchamiania narzędzia CMake.

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

Aby dowiedzieć się więcej na temat vcpkg.jsonusługi , zobacz dokumentację referencyjną:

Share via