Configurando um projeto

Poderíamos usar os arquivos tasks.json e launch.json para compilar e executar o código, como fizemos anteriormente. Entretanto, para projetos maiores, o CMake permite uma maior escalabilidade. Além disso, ele permite definir instruções de compilação diferentes para vários sistemas operacionais, além de argumentos opcionais, como flags de compilação e definições de pré-processador.

Projeto

Para não bagunçar o projeto oriented_graph, vamos copiá-lo para uma nova pasta chamada oriented_graph_with_cmake.

1
cd ~/dev/c_cpp_projects
2
cp -r oriented_graph oriented_graph_with_cmake
3
cd oriented_graph_with_cmake

Também podemos adotar a convenção de colocar todos os arquivos de código-fonte dentro de uma pasta chamada src.

1
mkdir -p src
2
mv main.cpp src
3
mv node src
4
mv edge src
5
mv graph src

Configuração geral

O principal arquivo de configuração do CMake é o CMakeLists.txt. Ele é responsável por definir as configurações do projeto e as dependências necessárias para a compilação.

Crie um arquivo chamado CMakeLists.txt na raiz da pasta oriented_graph. Atente-se à letras maiúsculas e minúsculas no nome do arquivo, ele precisa estar escrito exatamente como acima.

1
cd ~/dev/c_cpp_projects/oriented_graph_with_cmake
2
touch CMakeLists.txt
3
code .

Vamos preencher trecho por trecho do arquivo CMakeLists.txt para entender o que cada parte faz.

Versões

Primeiramente, é necessário definir a versão do CMake que será utilizada. Na época de escrita deste guia, a versão 3.31.6 era a mais recente disponível.

Nós podemos definir um intervalo de versões suportadas, para garantir que o projeto seja compilado corretamente em diferentes ambientes. Isso é feito com o comando cmake_minimum_required.

1
## Version
2
cmake_minimum_required(VERSION 3.12...3.31)

Em seguida, usamos um comando para garantir que versões anteriores à 3.12 passem por uma política de compatibilidade para conseguir realizar a compilação.

4
if (${CMAKE_VERSION} VERSION_LESS 3.12)
5
    cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
6
endif ()

Projeto

Agora, vamos definir o nome do projeto e a linguagem utilizada, que é o C++.

8
## Project
9
project(oriented_graph
10
        LANGUAGES CXX
11
)

Ambiente

O C++ tem várias versões, e pode ser customizado para diferentes ambientes. No nosso caso, queremos usar uma versão mais recente (no momento a 23) e compatível com o padrão oficial. Para isso, usamos comandos iniciados em set para definir as variáveis de ambiente.

13
## Environment
14
set(CMAKE_CXX_STANDARD 23)
15
set(CMAKE_CXX_STANDARD_REQUIRED ON)
16
set(CMAKE_CXX_EXTENSIONS OFF)

Flags de compilação

As flags de compilação são opções que podem ser passadas para o compilador para alterar o comportamento da compilação.

No nosso caso, queremos ativar todos os avisos de compilação. Além disso, é importante manter a compatibilidade com outros compiladores, como o GCC, o Apple Clang e MSVC.

Para isso, usamos o comando add_compile_options.

18
## Warnings
19
if (CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang|AppleClang")
20
    add_compile_options(
21
        -Wall -Wextra          # Reasonable warnings
22
        -Wpedantic             # Strict ISO C++ compliance
23
        -Wconversion           # Warn on implicit type conversions
24
        -Wsign-conversion      # Warn on signed/unsigned mismatches
25
    )
26
elseif (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
27
    add_compile_options(
28
        /W4                    # High warning level
29
        /permissive-           # Enforce standards compliance
30
    )
31
endif()

Diretórios

Nosso projeto guarda o código-fonte na pasta src. Para que o CMake consiga encontrar os arquivos dentro dela, precisamos listá-la no arquivo CMakeLists.txt.

34
## Directories
35
add_subdirectory(src)

Outras pastas comumente usadas são:

include: para arquivos de cabeçalho (.h ou .hpp);
lib: para bibliotecas externas;
tests: para testes automatizados;
docs: para documentação; e
assets: para arquivos estáticos, como imagens e fontes.

Nosso projeto não possui essas pastas, mas caso você venha a precisar em outros projetos, você usaria o comando add_subdirectory para cada uma delas.

Resultado

No final, o arquivo CMakeLists.txt deve ficar da seguinte forma.

1
## Version
2
cmake_minimum_required(VERSION 3.12...3.31)
3

4
if (${CMAKE_VERSION} VERSION_LESS 3.12)
5
    cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
6
endif ()
7

8
## Project
9
project(oriented_graph
10
        LANGUAGES CXX
11
)
12

13
## Environment
14
set(CMAKE_CXX_STANDARD 23)
15
set(CMAKE_CXX_STANDARD_REQUIRED ON)
16
set(CMAKE_CXX_EXTENSIONS OFF)
17

18
## Warnings
19
if (CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang|AppleClang")
20
    add_compile_options(
21
        -Wall -Wextra          # Reasonable warnings
22
        -Wpedantic             # Strict ISO C++ compliance
23
        -Wconversion           # Warn on implicit type conversions
24
        -Wsign-conversion      # Warn on signed/unsigned mismatches
25
    )
26
elseif (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
27
    add_compile_options(
28
        /W4                    # High warning level
29
        /permissive-           # Enforce standards compliance
30
    )
31
endif()
32

33
## Directories
34
add_subdirectory(src)

Código-fonte

Agora que já temos o arquivo CMakeLists.txt configurado, precisamos adicionar os arquivos de código-fonte, que estão na pasta src. Para isso, vamos criar um novo arquivo CMakeLists.txt dentro da pasta src.

1
touch src/CMakeLists.txt

Executável

Dentro deste novo arquivo src/CMakeLists.txt, precisamos definir o nome do arquivo executável que será gerado após a compilação. No nosso caso, o nome do executável será oriented_graph, e ele será gerado a partir do arquivo main.cpp.

1
## Executable
2
add_executable(oriented_graph
3
        main.cpp
4
)

Diretórios

Agora, precisamos adicionar os módulos que estão dentro da pasta src. Para isso, usamos o comando add_subdirectory para cada um deles.

6
## Directories
7
add_subdirectory(node)
8
add_subdirectory(edge)
9
add_subdirectory(graph)

Dependências

O arquivo principal, main.cpp, depende da classe Graph. Isso é definido pela importação do arquivo de cabeçalho graph.hpp, que está dentro da pasta graph.

3
#include "graph/graph.hpp"

Para que o CMake consiga vincular esse arquivo, precisamos adicionar a pasta graph como um diretório de inclusão. Isso é feito com o comando target_include_directories. Ele vai incluir o diretório graph de forma privada ao executável oriented_graph.

Aqui decidimos usar a keyword PRIVATE para que os outros módulos que main.cpp importa não sejam disponibilizados para arquivos que venham a incluir main.cpp. Isso é importante para evitar que outros módulos acessem arquivos que não deveriam.

11
## Linking libraries
12
target_link_libraries(oriented_graph
13
    PRIVATE
14
        graph
15
)

Resultado

No final, o arquivo src/CMakeLists.txt deve ficar da seguinte forma.

1
## Executable
2
add_executable(oriented_graph
3
        main.cpp
4
)
5

6
## Directories
7
add_subdirectory(node)
8
add_subdirectory(edge)
9
add_subdirectory(graph)
10

11
## Linking libraries
12
target_link_libraries(oriented_graph
13
    PRIVATE
14
        graph
15
)

Módulos

A forma de criar diferentes módulos no CMake é definir cada um como uma biblioteca estática. Elas são montadas por um arquivo *.hpp que contém funções e variáveis que podem ser utilizadas por outros arquivos do projeto.

Assim como fizemos para a pasta src, precisamos criar um arquivo CMakeLists.txt para cada módulo. Esses arquivos são responsáveis por definir as configurações específicas de cada um.

1
touch src/node/CMakeLists.txt
2
touch src/edge/CMakeLists.txt
3
touch src/graph/CMakeLists.txt

Biblioteca

Vamos tomar como exemplo o módulo edge, precisamos definir o nome da biblioteca, que será edge. Para isso, acesse o arquivo src/edge/CMakeLists.txt, e utilize o comando add_library.

1
## Library
2
add_library(edge)

Código-fonte

Em seguida, precisamos adicionar os arquivos de código-fonte e de cabeçalho que fazem parte do módulo. O módulo edge possui apenas um arquivo de cabeçalho, o edge.hpp, e um arquivo de código-fonte, o edge.cpp. Usaremos o comando target_sources para adicionar esses arquivos à biblioteca.

Os arquivos de cabeçalho são adicionados como públicos para que eles possam ser incluídos por outros módulos. Já os arquivos de código-fonte são adicionados como privados, de forma que outros módulos precisem utilizar o arquivo de cabeçalho para conseguir acessá-los.

4
## Sources
5
target_sources(edge
6
    PUBLIC
7
        edge.hpp
8
    PRIVATE
9
        edge.cpp
10
)

Diretórios

Agora, precisamos definir o diretório edge como um diretório de inclusão, para que ele possa ser acessado por outros módulos. Isso é feito com o comando target_include_directories.

O CMake vai incluir o diretório edge de forma pública à biblioteca edge. É necessário usar a keyword PUBLIC para que outros arquivos consigam incluir a classe Edge, definida no arquivo edge.hpp.

12
## Define module
13
target_include_directories(edge
14
    PUBLIC
15
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
16
)

Dependências

O módulo edge depende da classe Node. Isso é definido pela importação do arquivo de cabeçalho node.hpp, que está dentro da pasta node.

4
#include "../node/node.hpp"

Para que o CMake consiga vincular esse arquivo, precisamos adicionar a pasta node como um diretório de inclusão. Isso é feito com o comando target_link_libraries. Da mesma forma que fizemos para o executável oriented_graph, vamos incluir o diretório node de forma privada à biblioteca edge.

18
## Link libraries
19
target_link_libraries(edge
20
    PRIVATE
21
        node
22
)

O módulo node não possui dependências, então não precisamos nos preocupar com isso. Já o módulo graph depende do módulo node e do módulo edge. Dessa forma, devemos incluir ambos na lista de dependências do comando target_link_libraries.

Resultado

No final, o arquivo src/node/CMakeLists.txt deve ficar da seguinte forma.

1
## Library
2
add_library(node)
3

4
## Sources
5
target_sources(node
6
    PUBLIC
7
        node.hpp
8
    PRIVATE
9
        node.cpp
10
)
11

12
## Define module
13
target_include_directories(node
14
    PUBLIC
15
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
16
)

O arquivo src/edge/CMakeLists.txt deve ficar da seguinte forma.

1
## Library
2
add_library(edge)
3

4
## Sources
5
target_sources(edge
6
    PUBLIC
7
        edge.hpp
8
    PRIVATE
9
        edge.cpp
10
)
11

12
## Define module
13
target_include_directories(edge
14
    PUBLIC
15
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
16
)
17

18
## Link libraries
19
target_link_libraries(edge
20
    PRIVATE
21
        node
22
)

O arquivo src/graph/CMakeLists.txt deve ficar da seguinte forma.

1
## Library
2
add_library(graph)
3

4
## Sources
5
target_sources(graph
6
    PUBLIC
7
        graph.hpp
8
    PRIVATE
9
        graph.cpp
10
)
11

12
## Define module
13
target_include_directories(graph
14
    PUBLIC
15
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
16
)
17

18
## Link libraries
19
target_link_libraries(graph
20
    PRIVATE
21
        node
22
        edge
23
)

Git

Por fim, vamos fazer stage das modificações e realizar um novo commit.

1
git add .
2
git commit -m "Configure CMake"