Esercitazione: Installare e usare pacchetti con CMake

Articolo
09/26/2024

Questa esercitazione illustra come creare un programma "Hello World" C++ che usa la fmt libreria con CMake e vcpkg. Verranno installate dipendenze, configurate, compilate ed eseguite una semplice applicazione.

Prerequisiti

Un terminale
Compilatore C++
CMake
Git

Nota

Per gli utenti di Windows, MSVC di Visual Studio (compilatore Microsoft Visual C++) è il compilatore necessario per lo sviluppo C++.

1 - Configurare vcpkg

Clonare il repository

Il primo passaggio consiste nel clonare il repository vcpkg da GitHub. Il repository contiene script per acquisire l'eseguibile vcpkg e un registro di librerie open source curate gestite dalla community vcpkg. A tale scopo, eseguire:
```
git clone https://github.com/microsoft/vcpkg.git
```
Il registro curato vcpkg è un set di oltre 2.000 librerie open source. Queste librerie sono state convalidate dalle pipeline di integrazione continua di vcpkg per collaborare. Anche se il repository vcpkg non contiene il codice sorgente per queste librerie, contiene ricette e metadati per compilarli e installarli nel sistema.
Eseguire lo script bootstrap

Dopo aver clonato il repository vcpkg, passare alla vcpkg directory ed eseguire lo script bootstrap:
```
cd vcpkg && bootstrap-vcpkg.bat
```
```
cd vcpkg; .\bootstrap-vcpkg.bat
```
```
cd vcpkg && ./bootstrap-vcpkg.sh
```
Lo script bootstrap esegue i controlli dei prerequisiti e scarica il file eseguibile vcpkg.

Ecco fatto! vcpkg è configurato e pronto per l'uso.

2 - Configurare il progetto

Configurare la variabile di ambiente VCPKG_ROOT.
```
export VCPKG_ROOT=/path/to/vcpkg
export PATH=$VCPKG_ROOT:$PATH
```
Nota

L'impostazione delle variabili di ambiente tramite il export comando influisce solo sulla sessione della shell corrente. Per rendere permanente questa modifica tra le sessioni, aggiungere il export comando allo script del profilo della shell (ad esempio, ~/.bashrc o ~/.zshrc).
```
set "VCPKG_ROOT=C:\path\to\vcpkg"
set PATH=%VCPKG_ROOT%;%PATH%
```
Nota

L'impostazione delle variabili di ambiente in questo modo influisce solo sulla sessione del terminale corrente. Per rendere permanenti queste modifiche in tutte le sessioni, impostarle tramite il pannello Variabili di ambiente del sistema Windows.
```
$env:VCPKG_ROOT = "C:\path\to\vcpkg"
$env:PATH = "$env:VCPKG_ROOT;$env:PATH"
```
Nota

L'impostazione delle variabili di ambiente in questo modo influisce solo sulla sessione del terminale corrente. Per rendere permanenti queste modifiche in tutte le sessioni, impostarle tramite il pannello Variabili di ambiente del sistema Windows.
L'impostazione VCPKG_ROOT indica a vcpkg dove si trova l'istanza vcpkg. Aggiungendolo per PATH assicurarsi di poter eseguire comandi vcpkg direttamente dalla shell.
Creare la directory del progetto.
```
mkdir helloworld && cd helloworld
```

3 - Aggiungere dipendenze e file di progetto

Creare il file manifesto e aggiungere la fmt dipendenza.

Prima di tutto, creare un file manifesto (vcpkg.json) nella directory del progetto eseguendo il vcpkg new comando dall'interno della helloworld directory:
```
vcpkg new --application
```
Aggiungere quindi la fmt dipendenza:
```
vcpkg add port fmt
```
L’aspetto di vcpkg.json dovrebbe essere simile al seguente:
```
{
    "dependencies": [
        "fmt"
    ]
}
```
Questo è il file manifesto. vcpkg legge il file manifesto per informazioni sulle dipendenze da installare e integrare con CMake per fornire le dipendenze richieste dal progetto.

Il file predefinito vcpkg-configuration.json introduce vincoli di base , specificando le versioni minime delle dipendenze che il progetto deve usare. Durante la modifica di questo file non rientra nell'ambito di questa esercitazione, svolge un ruolo fondamentale nella definizione dei vincoli di versione per le dipendenze del progetto. Pertanto, anche se non è strettamente necessario per questa esercitazione, è consigliabile aggiungere vcpkg-configuration.json al controllo del codice sorgente per garantire la coerenza delle versioni in ambienti di sviluppo diversi.
Creare i file di progetto.

Creare il CMakeLists.txt file con il contenuto seguente:
```
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)
```
A questo punto, è possibile suddividere le operazioni che ogni riga nel CMakeLists.txt file esegue:
- cmake_minimum_required(VERSION 3.10): specifica che la versione minima di CMake necessaria per compilare il progetto è 3.10. Se la versione di CMake installata nel sistema è inferiore a questa, verrà generato un errore.
- project(HelloWorld): imposta il nome del progetto su "HelloWorld".
- find_package(fmt CONFIG REQUIRED): cerca la libreria usando il fmt relativo file di configurazione CMake. La REQUIRED parola chiave garantisce che venga generato un errore se il pacchetto non viene trovato.
- add_executable(HelloWorld helloworld.cpp): aggiunge una destinazione eseguibile denominata "HelloWorld", compilata dal file helloworld.cppdi origine .
- target_link_libraries(HelloWorld PRIVATE fmt::fmt): specifica che il HelloWorld file eseguibile deve essere collegato alla fmt libreria. La PRIVATE parola chiave indica che fmt è necessaria solo per la compilazione HelloWorld e non deve essere propagata ad altri progetti dipendenti.
Creare il helloworld.cpp file con il contenuto seguente:
```
#include <fmt/core.h>

int main()
{
    fmt::print("Hello World!\n");
    return 0;
}
```
In questo helloworld.cpp file l'intestazione è inclusa per l'uso <fmt/core.h> della fmt libreria. La main() funzione chiama fmt::print() quindi per inviare il messaggio "Hello World!" alla console.

4 - Compilare ed eseguire il progetto

Eseguire la configurazione di CMake

CMake può collegare automaticamente le librerie installate da vcpkg quando CMAKE_TOOLCHAIN_FILE è impostato per usare la toolchain personalizzata di vcpkg. Può essere uncomplished usando i file preimpostazioni di CMake.

Creare i file seguenti all'interno della helloworld directory:

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>"
        }
      }
    ]
  }
```
Il CMakePresets.json file contiene un singolo set di impostazioni denominato "vcpkg", che imposta la CMAKE_TOOLCHAIN_FILE variabile. Il CMakeUserPresets.json file imposta la VCPKG_ROOT variabile di ambiente in modo che punti al percorso assoluto contenente l'installazione locale di vcpkg. È consigliabile non controllare CMakeUserPresets.json i sistemi di controllo della versione.

Configurare infine la compilazione usando CMake:
```
cmake --preset=default
```
Compilare il progetto

Terza fase
```
cmake --build build
```
Eseguire l'applicazione

Eseguire infine l'eseguibile per visualizzare l'applicazione in azione:
```
./build/HelloWorld

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

Hello World!
```

Condividi tramite