Tutorial: Instalar e usar pacotes com vcpkg

Artigo
05/01/2024

Este tutorial mostra como criar um programa C++ "Hello World" que usa a fmt biblioteca com CMake e vcpkg. Você instalará dependências, configurará, compilará e executará um aplicativo simples.

Pré-requisitos

Um terminal
Um compilador C++
CMake
Git

Observação

Para usuários do Windows, o MSVC (Microsoft Visual C++ Compiler) do Visual Studio é o compilador necessário para o desenvolvimento em C++.

1 – Configurar vcpkg

Clonar o repositório

O primeiro passo é clonar o repositório vcpkg do GitHub. O repositório contém scripts para adquirir o executável vcpkg e um registro de bibliotecas de código aberto com curadoria mantidas pela comunidade vcpkg. Para fazer isso, execute:
```
git clone https://github.com/microsoft/vcpkg.git
```
O registro com curadoria vcpkg é um conjunto de mais de 2.000 bibliotecas de código aberto. Essas bibliotecas foram validadas pelos pipelines de integração contínua do vcpkg para trabalhar em conjunto. Embora o repositório vcpkg não contenha o código-fonte dessas bibliotecas, ele contém receitas e metadados para compilá-los e instalá-los em seu sistema.
Executar o script de bootstrap

Agora que você clonou o repositório vcpkg, navegue até o vcpkg diretório e execute o script de bootstrap:
```
cd vcpkg && bootstrap-vcpkg.bat
```
```
cd vcpkg; .\bootstrap-vcpkg.bat
```
```
cd vcpkg && ./bootstrap-vcpkg.sh
```
O script bootstrap executa verificações de pré-requisitos e baixa o executável vcpkg.

É isso! VCPKG está configurado e pronto para uso.

2 - Montar o projeto

Configurar as VCPKG_ROOT variáveis de ambiente.
```
export VCPKG_ROOT=/path/to/vcpkg
export PATH=$VCPKG_ROOT:$PATH
```
Observação

A definição de variáveis de ambiente usando o export comando afeta apenas a sessão do shell atual. Para tornar essa alteração permanente nas sessões, adicione o export comando ao script de perfil do shell (por exemplo, ~/.bashrc ou ~/.zshrc).
```
set VCPKG_ROOT="C:\path\to\vcpkg"
set PATH=%VCPKG_ROOT%;%PATH%
```
Observação

A configuração de variáveis de ambiente dessa maneira afeta apenas a sessão de terminal atual. Para tornar essas alterações permanentes em todas as sessões, defina-as por meio do painel Variáveis de Ambiente do Sistema do Windows.
```
$env:VCPKG_ROOT = "C:\path\to\vcpkg"
$env:PATH = "$env:VCPKG_ROOT;$env:PATH"
```
Observação

A configuração de variáveis de ambiente dessa maneira afeta apenas a sessão de terminal atual. Para tornar essas alterações permanentes em todas as sessões, defina-as por meio do painel Variáveis de Ambiente do Sistema do Windows.
A configuração VCPKG_ROOT informa ao vcpkg onde sua instância vcpkg está localizada. Adicioná-lo garante PATH que você possa executar comandos vcpkg diretamente do shell.
Crie o diretório do projeto.
```
mkdir helloworld && cd helloworld
```

3 - Adicionar dependências e arquivos de projeto

Crie o arquivo de manifesto e adicione a fmt dependência.

Primeiro, crie um arquivo de manifesto (vcpkg.json) no diretório do projeto executando o vcpkg new comando de dentro do helloworld diretório:
```
vcpkg new --application
```
Em seguida, adicione a fmt dependência:
```
vcpkg add port fmt
```
O vcpkg.json será parecido com este:
```
{
    "dependencies": [
        "fmt"
    ]
}
```
Este é o seu arquivo de manifesto. vcpkg lê o arquivo de manifesto para saber quais dependências instalar e integra com o CMake para fornecer as dependências exigidas pelo seu projeto.

O arquivo padrão vcpkg-configuration.json introduz restrições de linha de base , especificando as versões mínimas de dependências que seu projeto deve usar. Embora a modificação desse arquivo esteja além do escopo deste tutorial, ele desempenha um papel crucial na definição de restrições de versão para as dependências do seu projeto. Portanto, mesmo que não seja estritamente necessário para este tutorial, é uma boa prática adicionar vcpkg-configuration.json ao controle do código-fonte para garantir a consistência da versão em diferentes ambientes de desenvolvimento.
Crie os arquivos de projeto.

Crie o CMakeLists.txt arquivo com o seguinte conteúdo:
```
cmake_minimum_required(VERSION 3.10)

project(HelloWorld)

find_package(fmt CONFIG REQUIRED)

add_executable(HelloWorld main.cpp)

target_link_libraries(HelloWorld PRIVATE fmt::fmt)
```
Agora, vamos detalhar o que cada linha no CMakeLists.txt arquivo faz:
- cmake_minimum_required(VERSION 3.10): Especifica que a versão mínima do CMake necessária para compilar o projeto é 3.10. Se a versão do CMake instalada no seu sistema for inferior a esta, será gerado um erro.
- project(HelloWorld): Define o nome do projeto como "HelloWorld".
- find_package(fmt CONFIG REQUIRED): Procura a fmt biblioteca usando seu arquivo de configuração CMake. A REQUIRED palavra-chave garante que um erro seja gerado se o pacote não for encontrado.
- add_executable(HelloWorld main.cpp): Adiciona um destino executável chamado "HelloWorld", criado a partir do arquivo main.cppde origem .
- target_link_libraries(HelloWorld PRIVATE fmt::fmt): Especifica que o HelloWorld executável deve ser vinculado à fmt biblioteca. A PRIVATE palavra-chave indica que fmt é necessária apenas para a construção HelloWorld e não deve se propagar para outros projetos dependentes.
Crie o main.cpp arquivo com o seguinte conteúdo:
```
#include <fmt/core.h>

int main()
{
    fmt::print("Hello World!\n");
    return 0;
}
```
Nesse main.cpp arquivo, o <fmt/core.h> cabeçalho é incluído para usar a fmt biblioteca. A main() função, em seguida, chama fmt::print() para enviar a mensagem "Hello World!" para o console.

4 - Construir e executar o projeto

Executar a configuração do CMake

Para permitir que o sistema de projeto CMake reconheça bibliotecas C++ fornecidas pelo vcpkg, você precisará fornecer o vcpkg.cmake arquivo toolchain. Para automatizar isso, crie um CMakePresets.json arquivo no diretório "helloworld" com o seguinte conteúdo:
```
{
  "version": 2,
  "configurePresets": [
    {
      "name": "default",
      "generator": "Ninja",
      "binaryDir": "${sourceDir}/build",
      "cacheVariables": {
        "CMAKE_TOOLCHAIN_FILE": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake"
      }
    }
  ]
}
```
Esse CMakePresets.json arquivo contém uma única predefinição "padrão" para CMake e define a CMAKE_TOOLCHAIN_FILE variável. O CMAKE_TOOLCHAIN_FILE permite que o sistema de projeto CMake reconheça bibliotecas C++ fornecidas pelo vcpkg. Adicionar o CMakePresets.json automatiza o processo de especificação do toolchain ao executar o CMake.

Configure a compilação usando o CMake:
```
cmake --preset=default
```
Compilar o projeto

Correr:
```
cmake --build build
```
Executar o aplicativo

Finalmente, execute o executável para ver seu aplicativo em ação:
```
./build/HelloWorld

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

Hello World!
```

Próximas etapas

Para saber mais sobre vcpkg.jsono , consulte nossa documentação de referência:

Compartilhar via