Condividi tramite

Esercitazione: Installare una dipendenza da un file manifesto

  • Articolo

vcpkg ha due modalità operative: la modalità classica e la modalità manifesto. Questo articolo descrive come installare i pacchetti usando la modalità manifesto, ovvero il flusso di lavoro consigliato per la maggior parte degli utenti.

In modalità manifesto si dichiarano le dipendenze dirette del progetto in un file manifesto denominato vcpkg.json.

I file manifesto hanno la propria vcpkg_installed directory in cui installano le dipendenze, a differenza della modalità classica, in cui tutti i pacchetti vengono installati in una directory comune %VCPKG_ROOT%/installed . Di conseguenza, ogni progetto può avere il proprio manifesto e il proprio set di dipendenze che non sono in conflitto con le dipendenze di altri progetti.

La modalità manifesto è necessaria anche per usare funzionalità avanzate come il controllo delle versioni e i registri personalizzati.

La presente esercitazione include informazioni su come:

Prerequisiti

  • vcpkg
  • Un terminale
  • Editor di codice
  • Compilatore C++
  • (Facoltativo) CMake o MSBuild

1 - Creare un progetto con un manifesto

In una nuova cartella creare un file di origine denominato main.cxx con questi contenuti:

#include <cxxopts.hpp>
#include <fmt/format.h>
#include <range/v3/view.hpp>

namespace view = ranges::views;

int fib(int x)
{
  int a = 0, b = 1;

  for (int it : view::repeat(0) | view::take(x))
  {
    (void)it;
    int tmp = a;
    a += b;
    b = tmp;
  }

  return a;
}

int main(int argc, char **argv)
{
  cxxopts::Options options("fibo", "Print the fibonacci sequence up to a value 'n'");
  options.add_options()("n,value", "The value to print to", cxxopts::value<int>()->default_value("10"));

  auto result = options.parse(argc, argv);
  auto n = result["value"].as<int>();

  for (int x : view::iota(1) | view::take(n))
  {
    fmt::print("fib({}) = {}\n", x, fib(x));
  }
}

Il codice fa riferimento alle librerie open source: cxxopts, fmte range-v3, che sono tutte disponibili nel registro pubblico vcpkg all'indirizzo https://github.com/Microsoft/vcpkg.

Per dichiarare queste dipendenze, creare un file denominato vcpkg.json nella stessa directory del progetto:

vcpkg.json:

{
  "dependencies": [
    "cxxopts",
    "fmt",
    "range-v3"
  ]
}

È sufficiente specificare le dipendenze dirette nell'elenco "dependencies" . Quando viene eseguito, vcpkg risolve e installa le eventuali dipendenze transitive necessarie.

2 - Integrare vcpkg con il sistema di compilazione

In questo passaggio viene illustrato come integrare vcpkg con CMake o MSBuild, in modo che le dipendenze del progetto vengano installate o ripristinate automaticamente ogni volta che si compila il progetto.

Se si usa un sistema di compilazione diverso, passare al passaggio successivo: Installare le dipendenze.

Altre informazioni sull'uso di vcpkg da MSBuild

Per usare vcpkg nei progetti MSBuild, eseguire il comando seguente:

vcpkg integrate install

È sufficiente eseguire il comando la prima volta che si vuole abilitare l'integrazione vcpkg integrate install di MSBuild. In questo modo si abilita l'integrazione di MSBuild per tutti i progetti esistenti e futuri. Usare vcpkg integrate remove per rimuovere l'integrazione a livello di sistema di MSBuild.

Questo metodo di integrazione aggiunge automaticamente i pacchetti installati da vcpkg alle proprietà del progetto seguenti: Include Directories, Link Directoriese Link Libraries. Viene inoltre creata un'azione di post-compilazione che garantisce che tutte le DLL necessarie vengano copiate nella cartella di output della compilazione. Questa soluzione funziona per tutte le soluzioni e i progetti che usano Visual Studio 2015 o versione successiva.

3 - Installare le dipendenze

Se si usa CMake o MSBuild e si è seguito il passaggio precedente, è possibile passare al passaggio successivo: Compilare il progetto.

Se si usa un sistema di compilazione diverso o si vuole installare manualmente le dipendenze, è sufficiente eseguire vcpkg install nella directory contenente il file manifesto.

PS D:\projects\manifest-example> vcpkg install
Detecting compiler hash for triplet x64-windows...
The following packages will be built and installed:
    cxxopts:x64-windows -> 3.1.1
    fmt:x64-windows -> 10.0.0
    range-v3:x64-windows -> 0.12.0#1
  * vcpkg-cmake:x64-windows -> 2023-05-04
  * vcpkg-cmake-config:x64-windows -> 2022-02-06#1
Additional packages (*) will be modified to complete this operation.
Installing 1/5 vcpkg-cmake-config:x64-windows...
Installing 2/5 vcpkg-cmake:x64-windows...
Installing 3/5 cxxopts:x64-windows...
Installing 4/5 fmt:x64-windows...
Installing 5/5 range-v3:x64-windows...
Total install time: 48 s
cxxopts provides CMake targets:

    # this is heuristically generated, and may not be correct
    find_package(cxxopts CONFIG REQUIRED)
    target_link_libraries(main PRIVATE cxxopts::cxxopts)

The package fmt provides CMake targets:

    find_package(fmt CONFIG REQUIRED)
    target_link_libraries(main PRIVATE fmt::fmt)

    # Or use the header-only version
    find_package(fmt CONFIG REQUIRED)
    target_link_libraries(main PRIVATE fmt::fmt-header-only)

range-v3 provides CMake targets:

    # this is heuristically generated, and may not be correct
    find_package(range-v3 CONFIG REQUIRED)
    target_link_libraries(main PRIVATE range-v3::meta range-v3::concepts range-v3::range-v3)

Al termine del comando, tutti i pacchetti compilati saranno presenti in una vcpkg_installed directory. Il percorso specifico di questa directory dipende dal sistema di compilazione; in genere, all'interno della cartella di output predefinita del sistema di compilazione o accanto al vcpkg.json file.

4 - Compilare il progetto

Per impostazione predefinita, la modalità manifesto è disabilitata nei progetti MSBuild.

Per abilitare i manifesti nel progetto, impostare la VcpkgEnableManifest proprietà nel .vcxproj file:

<PropertyGroup Label="Vcpkg">
  <VcpkgEnableManifest>true</VcpkgEnableManifest>
</PropertyGroup>

In alternativa, è possibile abilitare la modalità manifesto nella chiamata a MSBuild passando msbuild /p:VcpkgEnableManifest=true come parametro.

PS D:\projects\manifest-example> msbuild /p:VcpkgEnableManifest=true
MSBuild version 17.7.0-preview-23319-02+6829506b8 for .NET Framework
Build started 8/11/2023 11:29:50 AM.

Project "D:\projects\manifest-example\manifest-example.sln" on node 1 (default targets).
ValidateSolutionConfiguration:
  Building solution configuration "Debug|x64".
Project "D:\projects\manifest-example\manifest-example.sln" (1) is building "D:\projects\manifest-example\manifest-example.vcxproj" (2) on node 1 (default targets).
PrepareForBuild:
  (omitted)
InitializeBuildStatus:
  (omitted)
ComputeStdModulesCompileInputs:
  (omitted)
SetModuleDependencies:
  Creating directory "x64\Debug\manifest.ceffc6eb_MD.tlog\".
VcpkgTripletSelection:
  Using triplet "x64-windows" from "D:\projects\manifest-example\vcpkg_installed\x64-windows\x64-windows\"
  Using normalized configuration "Debug"
VcpkgInstallManifestDependencies:
  Installing vcpkg dependencies to D:\projects\manifest-example\vcpkg_installed\x64-windows\
  Creating directory "D:\projects\manifest-example\vcpkg_installed\x64-windows\".
  "D:\vcpkg\vcpkg.exe" install  --x-wait-for-lock --triplet "x64-windows" --vcpkg-root "D:\vcpkg\" "--x-manifest-root=D:\projects\manifest-example\" "--x-install-root=D:\projects\manifest-example\vcpkg_installed\x64-windows\"
  "D:\vcpkg\vcpkg.exe" install  --x-wait-for-lock --triplet "x64-windows" --vcpkg-root "D:\vcpkg\" "--x-manifest-root=D:\projects\manifest-example\" "--x-install-root=D:\projects\manifest-example\vcpkg_installed\x64-windows\"
  Detecting compiler hash for triplet x64-windows...
  The following packages will be built and installed:
      cxxopts:x64-windows -> 3.1.1
      fmt:x64-windows -> 10.0.0
      range-v3:x64-windows -> 0.12.0#1
    * vcpkg-cmake:x64-windows -> 2023-05-04
    * vcpkg-cmake-config:x64-windows -> 2022-02-06#1
  (omitted)
ClCompile:
  (omitted)
Link:
  (omitted)
AppLocalFromInstalled:
  pwsh.exe -ExecutionPolicy Bypass -noprofile -File "D:\vcpkg\scripts\buildsystems\msbuild\applocal.ps1" "D:\projects\manif
  est-mode-msbuild\x64\Debug\manifest-example.exe" "D:\projects\manifest-example\vcpkg_installed\x64-windows\x64-windows\debug\bin"
  "x64\Debug\manifest.ceffc6eb.tlog\manifest-example.write.1u.tlog" "x64\Debug\vcpkg.applocal.log"
  D:\projects\manifest-example\x64\Debug\fmtd.dll
FinalizeBuildStatus:
  (omitted)
Done Building Project "D:\projects\manifest-example\manifest-example.vcxproj" (default targets).

Done Building Project "D:\projects\manifest-example\manifest-example.sln" (default targets).

Build succeeded.

Passaggi successivi

In questa guida sono state installate dipendenze per un progetto semplice usando un file manifesto.

Ecco alcune attività aggiuntive da provare:

  • Installare pacchetti per piattaforme personalizzate, compilatori o architetture di compilazione usando triplette
  • Bloccare le versioni per le build ripetibili usando il controllo delle versioni
  • Riutilizzare i file binari nelle esecuzioni di integrazione locale o continua usando la memorizzazione nella cache binaria
  • Gestire le librerie private usando registri personalizzati