Tutorial: Instalar e usar pacotes com o CMake

Artigo
09/26/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 o vcpkg

Clonar o repositório

A primeira etapa é 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 selecionadas 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 trabalharem juntas. 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 de bootstrap executa verificações de pré-requisitos e baixa o executável vcpkg.

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

2 - Configure o projeto

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

A configuração de variáveis de ambiente usando o export comando afeta apenas a sessão atual do shell. Para tornar essa alteração permanente entre as 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

Definir 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

Definir 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 seu 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. O vcpkg lê o arquivo de manifesto para saber quais dependências instalar e se integra ao 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 helloworld.cpp)

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

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

4 - Construa e execute o projeto

Executar a configuração do CMake

O CMake pode vincular automaticamente as bibliotecas instaladas pelo vcpkg quando CMAKE_TOOLCHAIN_FILE estiver configurado para usar a cadeia de ferramentas personalizada do vcpkg. Isso pode ser feito usando arquivos de predefinições do CMake.

Crie os seguintes arquivos dentro do helloworld diretório:

CMakePresets.json
```
{
  "version": 2,
  "configurePresets": [
    {
      "name": "vcpkg",
      "generator": "Ninja",
      "binaryDir": "${sourceDir}/build",
      "cacheVariables": {
        "CMAKE_TOOLCHAIN_FILE": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake"
      }
    }
  ]
}
```
CMakeUserPresets.json
```
{
    "version": 2,
    "configurePresets": [
      {
        "name": "default",
        "inherits": "vcpkg",
        "environment": {
          "VCPKG_ROOT": "<path to vcpkg>"
        }
      }
    ]
  }
```
O CMakePresets.json arquivo contém uma única predefinição chamada "vcpkg", que define a CMAKE_TOOLCHAIN_FILE variável. O CMakeUserPresets.json arquivo define a VCPKG_ROOT variável de ambiente para apontar para o caminho absoluto que contém a instalação local do vcpkg. É recomendável não fazer check-in CMakeUserPresets.json em sistemas de controle de versão.

Por fim, configure a compilação usando o CMake:
```
cmake --preset=default
```
Compilar o projeto

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

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

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

Hello World!
```

Compartilhar via