Esercitazione: Installare e usare pacchetti con CMake in Visual Studio Code

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

Prerequisiti

• Visual Studio Code
• Compilatore C++
• Windows 7 o versione successiva

1 - Configurare vcpkg

1. 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.

2. 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 - Creare una cartella di progetto

Creare una cartella per contenere i file di progetto in un percorso di propria scelta. Per questa esercitazione viene creata una cartella denominata "helloworld". Aprire quindi la cartella usando Visual Studio Code.

mkdir helloworld
code helloworld

3 - Installare le estensioni di Visual Studio Code

Passare alla visualizzazione Estensione e installare l'estensione C++. In questo modo è possibile usare IntelliSense C++ e lo spostamento del codice.

Installare l'estensione CMake Tools. In questo modo viene abilitato il supporto di CMake in Visual Studio Code.

4 - Configurare le variabili di ambiente

1. Configurare la VCPKG_ROOT variabile di ambiente.

Aprire un nuovo terminale in Visual Studio Code: Nuovo terminale >

Eseguire i comandi seguenti:

$env:VCPKG_ROOT="C:\path\to\vcpkg"
$env:PATH="$env:VCPKG_ROOT;$env:PATH"

set "VCPKG_ROOT=C:\path\to\vcpkg"
set PATH=%VCPKG_ROOT%;%PATH%

export VCPKG_ROOT=/c/path/to/vcpkg
export PATH=$PATH:$VCPKG_ROOT

L'impostazione VCPKG_ROOT consente a Visual Studio Code di individuare l'istanza vcpkg. Aggiungendolo per PATH assicurarsi di poter eseguire comandi vcpkg direttamente dalla shell.

2. Generare un file manifesto e aggiungere dipendenze.

Eseguire il comando seguente per creare un file manifesto vcpkg (vcpkg.json) nella radice della helloworld cartella:

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 MSBuild 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.

5 - Configurare i file di progetto

1. Creare il CMakeLists.txt file

Creare un nuovo file denominato CMakeLists.txt nella radice della cartella del progetto 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)

Di seguito viene illustrato come suddividere ogni riga nel CMakeLists.txt file:

• 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.

2. 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.

Per consentire al sistema di progetto CMake di riconoscere le librerie C++ fornite da vcpkg, è necessario fornire il vcpkg.cmake file toolchain. Per automatizzare questa operazione, creare un CMakePresets.json file nella directory "helloworld" con il contenuto seguente:

{
  "version": 2,
  "configurePresets": [
    {
      "name": "vcpkg",
      "generator": "Ninja",
      "binaryDir": "${sourceDir}/build",
      "cacheVariables": {
        "CMAKE_TOOLCHAIN_FILE": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake"
      }
    }
  ]
}

3. Creare CMakeUserPresets.json un file nella directory "helloworld" con il contenuto seguente:

{
    "version": 2,
    "configurePresets": [
      {
        "name": "default",
        "inherits": "vcpkg",
        "environment": {
          "VCPKG_ROOT": "<path to vcpkg>"
        }
      }
    ]
  }

Questo CMakePresets.json file contiene un singolo set di impostazioni "vcpkg" per CMake e imposta la CMAKE_TOOLCHAIN_FILE variabile. CMAKE_TOOLCHAIN_FILE consente al sistema di progetto CMake di riconoscere le librerie C++ fornite da vcpkg. Deve essere archiviato solo CMakePresets.json nel controllo del codice sorgente mentre CMakeUserPresets.json deve essere usato in locale.

6 - Compilare ed eseguire il progetto

1. Eseguire il CMake: Build comando per il progetto passando al riquadro comandi in Visualizza > riquadro comandi

Selezionare il default set di impostazioni CMake. In questo modo viene abilitata la toolchain vcpkg.

2. Avviare il progetto

Eseguire il programma:

./build/HelloWorld.exe

./build/HelloWorld

Verrà visualizzato l'output:

Hello World!

Passaggi successivi

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

• Creazione di pacchetti di una libreria
• vcpkg.json
• manifest