Partilhar via

Tutorial: Instalar uma dependência a partir de um ficheiro de manifesto

  • Artigo

VCPKG tem dois modos de operação: modo clássico e modo manifesto. Este artigo descreve como instalar pacotes usando o modo de manifesto, que é o fluxo de trabalho recomendado para a maioria dos usuários.

No modo de manifesto, você declara as dependências diretas do projeto em um arquivo de manifesto chamado vcpkg.json.

Os arquivos de manifesto têm seu próprio diretório vcpkg_installed onde instalam dependências, ao contrário do modo clássico, onde todos os pacotes são instalados em um diretório %VCPKG_ROOT%/installed comum. Portanto, cada projeto pode ter seu próprio manifesto e seu próprio conjunto de dependências que não entram em conflito com as dependências de outros projetos.

O modo de manifesto também é necessário para usar recursos avançados, como controle de versão e registros personalizados .

Neste tutorial, você aprenderá a:

Pré-requisitos

  • vcpkg
  • Um terminal
  • Um editor de código
  • Um compilador C++
  • (Opcional) CMake ou MSBuild

1 - Criar um projeto com um manifesto

Em uma nova pasta, crie um arquivo de origem chamado main.cxx com este conteúdo:

#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));
  }
}

O código faz referência às bibliotecas de código aberto: cxxopts, fmte range-v3; que estão todos disponíveis no registo público da VCPKG em https://github.com/Microsoft/vcpkg.

Para declarar essas dependências, crie um arquivo chamado vcpkg.json no mesmo diretório do seu projeto:

vcpkg.json:

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

Você só precisa especificar suas dependências diretas na lista "dependencies". Quando é executado, o vcpkg resolve e instala todas as dependências transitivas necessárias.

2 - Integre o vcpkg com o seu sistema de compilação

Nesta etapa, mostramos como integrar vcpkg com CMake ou MSBuild, para que suas dependências de projeto sejam instaladas ou restauradas automaticamente sempre que você construir o projeto.

Se você estiver usando um sistema de compilação diferente, pule para a próxima etapa: Instalar dependências.

Saiba mais sobre como usar vcpkg do MSBuild

Para usar vcpkg em seus projetos MSBuild, execute o seguinte comando:

vcpkg integrate install

Você só precisa executar o comando vcpkg integrate install na primeira vez que quiser habilitar a integração do MSBuild. Isso permite a integração do MSBuild para todos os seus projetos atuais e futuros. Use vcpkg integrate remove para remover a integração de todo o sistema MSBuild.

Esse método de integração adiciona automaticamente pacotes instalados no vcpkg às seguintes propriedades do projeto: Include Directories, Link Directoriese Link Libraries. Além disso, isso cria uma ação pós-compilação que garante que todas as DLLs necessárias sejam copiadas para a pasta de saída da compilação. Isso funciona para todas as soluções e projetos que usam o Visual Studio 2015 ou mais recente.

3 - Instalar dependências

Se você estiver usando CMake ou MSBuild e seguiu a etapa anterior, você pode pular para a próxima etapa: Criar o projeto.

Se você estiver usando um sistema de compilação diferente ou quiser instalar as dependências manualmente, tudo o que você precisa fazer é executar vcpkg install no diretório que contém seu arquivo de 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)

Quando o comando terminar, todos os pacotes construídos estarão presentes em um diretório vcpkg_installed. A localização específica deste diretório depende do seu sistema de compilação; Normalmente, dentro da pasta de saída padrão do sistema de compilação ou ao lado do seu arquivo vcpkg.json.

4 - Construa o projeto

Por padrão, o modo de manifesto está desabilitado em projetos MSBuild.

Para habilitar manifestos em seu projeto, defina a propriedade VcpkgEnableManifest em seu arquivo .vcxproj:

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

Como alternativa, você pode habilitar o modo de manifesto em sua chamada MSBuild passando msbuild /p:VcpkgEnableManifest=true como um parâmetro.

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.

Próximos passos

Neste guia, você instalou dependências para um projeto simples usando um arquivo de manifesto.

Aqui estão algumas tarefas adicionais para tentar a seguir:

  • Instale pacotes para plataformas personalizadas, compiladores ou arquiteturas de compilação usando triplets
  • Bloqueie as suas versões para compilações repetíveis usando versão
  • Reutilize binários em execuções de integração local ou contínua usando cache binário
  • Gerencie suas bibliotecas particulares usando registros de personalizados