Esercitazione: Installare e usare pacchetti con CMake in Visual Studio

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

Prerequisiti

Carico di lavoro sviluppo di Visual Studio con C++ e componente CMake
Git

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 di Visual Studio

Creare il progetto di Visual Studio
- Creare un nuovo progetto in Visual Studio usando il modello "Progetto CMake"
Screenshot dell'interfaccia utente di Visual Studio per mostrare come creare un nuovo progetto CMake in Visual Studio
- Assegnare al progetto il nome "helloworld"
- Selezionare la casella "Inserisci soluzione e progetto nella stessa directory".
- Fare clic sul pulsante "Crea"
Screenshot dell'interfaccia utente di Visual Studio per assegnare un nome al progetto CMake e fare clic sul pulsante "Crea".
Configurare la variabile di ambiente VCPKG_ROOT.

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.
Aprire la finestra predefinita di PowerShell per sviluppatori in Visual Studio.

Screenshot dell'interfaccia utente di Visual Studio per la finestra di sviluppo predefinita di PowerShell

Eseguire i comandi seguenti:
```
$env:VCPKG_ROOT="C:\path\to\vcpkg"
$env:PATH="$env:VCPKG_ROOT;$env:PATH"
```
Screenshot dell'interfaccia utente di Visual Studio per la finestra predefinita per sviluppatori di PowerShell che mostra come configurare VCPKG_ROOT e aggiungerla a PATH.
Aprire il prompt dei comandi per gli sviluppatori in Visual Studio.

Screenshot dell'interfaccia utente di Visual Studio per il prompt dei comandi per gli sviluppatori.

Eseguire i comandi seguenti:
```
set "VCPKG_ROOT=C:\path\to\vcpkg"
set PATH=%VCPKG_ROOT%;%PATH%
```
Screenshot del prompt dei comandi per sviluppatori di Visual Studio che mostra come configurare VCPKG_ROOT e aggiungerlo a PATH.
L'impostazione VCPKG_ROOT consente a Visual Studio di individuare l'istanza di vcpkg. Aggiungendolo per PATH assicurarsi di poter eseguire comandi vcpkg direttamente dalla shell.
Generare un file manifesto e aggiungere dipendenze.

Eseguire il comando seguente per creare un file manifesto vcpkg (vcpkg.json):
```
vcpkg new --application
```
Il vcpkg new comando aggiunge un vcpkg.json file e un vcpkg-configuration.json file nella directory del progetto.

Aggiungere il fmt pacchetto come dipendenza:
```
vcpkg add port fmt
```
Il vcpkg.json file dovrebbe ora contenere:
```
{
    "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 generato vcpkg-configuration.json introduce una baseline che inserisce vincoli di versione minimi sulle dipendenze del progetto. La modifica di questo file non rientra nell'ambito di questa esercitazione. Anche se non applicabile in questa esercitazione, è consigliabile mantenere il file sotto il controllo del vcpkg-configuration.json codice sorgente per garantire la coerenza delle versioni in ambienti di sviluppo diversi.

3 - Configurare i file di progetto

Modificare il file helloworld.cpp.

Sostituire il contenuto di helloworld.cpp con il codice seguente:
```
#include <fmt/core.h>

int main()
{
    fmt::print("Hello World!\n");
    return 0;
}
```
Questo file di origine include l'intestazione <fmt/core.h> che fa parte della fmt libreria. La main() funzione chiama fmt::print() per inviare il messaggio "Hello World!" alla console.
Configurare il CMakePresets.json file.

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.

Modificare CMakePresets.json in modo che corrisponda al contenuto seguente:
```
{
  "version": 2,
  "configurePresets": [
    {
      "name": "vcpkg",
      "generator": "Ninja",
      "binaryDir": "${sourceDir}/build",
      "cacheVariables": {
        "CMAKE_TOOLCHAIN_FILE": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake"
      }
    }
  ]
}
```
Creare CMakeUserPresets.json con il contenuto seguente:
```
{
  "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.
Modificare il file CMakeLists.txt.

Sostituire il contenuto del file CMakeLists.txt con il codice 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, la compilazione non riesce.
- 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.

4 - Compilare ed eseguire il progetto

Compilare il progetto.

Compilare il progetto usando l'opzione Build > Build All dal menu in alto.
Eseguire l'applicazione.

Infine, eseguire il file eseguibile:

Screenshot dell'interfaccia utente di Visual Studio per l'esecuzione del file eseguibile.

Verrà visualizzato l'output:

Screenshot degli output del programma - "Hello World!"

Passaggi successivi

Per altre informazioni su vcpkg.json, vedere la documentazione di riferimento:

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2024-09-26