Configurando o Visual Studio Code

Podemos aprimorar nosso ambiente de desenvolvimento configurando o Visual Studio Code para trabalhar com o CMake. Isso nos permitirá compilar e executar nossos projetos diretamente do editor, sem precisar abrir o terminal.

Snippets

A estrutura dos arquivos CMakeLists.txt é semelhante, independentemente do projeto que você estiver criando. Então, podemos criar snippets para facilitar sua criação.

Para isso, abra a paleta de comandos do Visual Studio Code com Control + Shift + P Control + Shift + P e busque por Snippets: Configure Snippets. Então, selecione New Global Snippets file.... Quando solicitado, digite o nome do arquivo como cmake e pressione Enter Enter . Isso abrirá um arquivo JSON onde podemos definir nossos snippets.

Copie o seguinte código para o arquivo aberto.

1
{
2
  "CMakeLists.txt (library)": {
3
    "body": [
4
      "## Library",
5
      "add_library(my_second_library)",
6
      "",
7
      "## Sources",
8
      "target_sources(my_second_library",
9
      "    PUBLIC",
10
      "        my_second_library.hpp",
11
      "    PRIVATE",
12
      "        my_second_library.cpp",
13
      ")",
14
      "",
15
      "## Define module",
16
      "target_include_directories(my_second_library",
17
      "    PUBLIC",
18
      "        \\$<BUILD_INTERFACE:\\${CMAKE_CURRENT_SOURCE_DIR}>",
19
      ")",
20
      "",
21
      "## Link libraries",
22
      "target_link_libraries(my_second_library",
23
      "    PRIVATE",
24
      "        my_first_library",
25
      ")",
26
      "",
27
    ],
28
    "description": "CMakeLists.txt file to configure a static library in CMake.",
29
    "isFileTemplate": true,
30
    "prefix": "cmake-library",
31
  },
32
  "CMakeLists.txt (main)": {
33
    "body": [
34
      "## Version",
35
      "cmake_minimum_required(VERSION 3.12...3.31)",
36
      "",
37
      "if (\\${CMAKE_VERSION} VERSION_LESS 3.12)",
38
      "    cmake_policy(VERSION \\${CMAKE_MAJOR_VERSION}.\\${CMAKE_MINOR_VERSION})",
39
      "endif ()",
40
      "",
41
      "## Project",
42
      "project(my_project",
43
      "        LANGUAGES CXX",
44
      ")",
45
      "",
46
      "## Environment",
47
      "set(CMAKE_CXX_STANDARD 23)",
48
      "set(CMAKE_CXX_STANDARD_REQUIRED ON)",
49
      "set(CMAKE_CXX_EXTENSIONS OFF)",
50
      "",
51
      "## Warnings",
52
      "if (CMAKE_CXX_COMPILER_ID MATCHES \"GNU|Clang|AppleClang\")",
53
      "    add_compile_options(",
54
      "        -Wall -Wextra          # Reasonable warnings",
55
      "        -Wpedantic             # Strict ISO C++ compliance",
56
      "        -Wconversion           # Warn on implicit type conversions",
57
      "        -Wsign-conversion      # Warn on signed/unsigned mismatches",
58
      "    )",
59
      "elseif (CMAKE_CXX_COMPILER_ID STREQUAL \"MSVC\")",
60
      "    add_compile_options(",
61
      "        /W4                    # High warning level",
62
      "        /permissive-           # Enforce standards compliance",
63
      "    )",
64
      "endif()",
65
      "",
66
      "## Directories",
67
      "add_subdirectory(src)",
68
      "",
69
    ],
70
    "description": "CMakeLists.txt file to configure a project in CMake.",
71
    "isFileTemplate": true,
72
    "prefix": "cmake-main",
73
  },
74
  "CMakeLists.txt (src)": {
75
    "body": [
76
      "## Executable",
77
      "add_executable(my_project",
78
      "        main.cpp",
79
      ")",
80
      "",
81
      "## Directories",
82
      "add_subdirectory(my_first_library)",
83
      "add_subdirectory(my_second_library)",
84
      "",
85
      "## Linking libraries",
86
      "target_link_libraries(my_project",
87
      "    PRIVATE",
88
      "        my_second_library",
89
      ")",
90
      "",
91
    ],
92
    "description": "CMakeLists.txt file to configure the source directory in CMake.",
93
    "isFileTemplate": true,
94
    "prefix": "cmake-src",
95
  },
96
  "Debug launcher (CMake) (Local)": {
97
    "body": [
98
      "{",
99
      "  \"name\": \"LLDB: launch CMake project (Local)\",",
100
      "  \"type\": \"lldb\",",
101
      "  \"request\": \"launch\",",
102
      "  \"program\": \"\\${command:cmake.launchTargetPath}\",",
103
      "  \"args\": [],",
104
      "  \"cwd\": \"\\${workspaceFolder}\",",
105
      "  \"terminal\": \"console\",",
106
      "  \"preLaunchTask\": \"CMake: build\"",
107
      "}",
108
    ],
109
    "description": "Launch a program compiled by CMake using LLDB",
110
    "prefix": "cmake-launch",
111
  },
112
}

Lembre-se de salvar o arquivo. Feche e abra o VSCode para que as alterações tenham efeito.

O arquivo cmake.code-snippets contém os seguintes snippets:

cmake-main: cria um arquivo CMakeLists.txt para a raiz do projeto;
cmake-src: cria um arquivo CMakeLists.txt para o diretório src;
cmake-library: cria um arquivo CMakeLists.txt para um módulo que você criar dentro do diretório src;
cmake-launch: cria uma entrada de configuração de depuração para o arquivo launch.json do projeto.

Configuração

Podemos configurar o VSCode para que a extensão CMake Tools execute as tarefas de configuração do projeto.

Primeiro, delete a pasta build que criamos anteriormente.

Então, no VsCode, clique no ícone do CMake Tools na barra lateral esquerda. Ele é formado por um triângulo e uma chave de boca. Essa seção mostra a configuração de compilação do projeto.

Menu do CMake Tools, em que se seleciona um kit de configuração. — Seleção de um kit de configuração no menu do CMake Tools.

Então, no menu que se abrir no centro superior da tela, selecione o kit Clang. Tome cuidado para não selecionar o kit Clang-cl, uma vez que ele é usado para compilar para Windows.

Menu de seleção de kit, em que se vê a opção "Clang" selecionada. — Seleção do kit Clang.

Caso não haja o compilador Clang, verifique se ele está instalado no seu sistema e suas variáveis de ambiente estão configuradas corretamente. Então, escolha a opção [Scan for kits] para atualizar a lista de kits disponíveis.

Compilando

Para configurar a compilação do projeto, abra a paleta de comandos do VSCode com Control + Shift + P Control + Shift + P e busque por CMake: Configure, então selecione essa opção.

Já para compilar o projeto, abra a paleta de comando, busque por CMake: Build e selecione essa opção.

Menu da paleta de comandos do Visual Studio Code, em que se vê a opção "CMake: Build" selecionada. — Compilando pela paleta de comandos do Visual Studio Code.

Você também pode compilar o projeto clicando no botão Build, que tem um ícone de engrenagem no canto inferior esquerdo da tela.

O VsCode imprimirá na seção de Output o processo de compilação do projeto.

Seção de Output do Visual Studio Code, em que se vê a saída da compilação do projeto. — Saída da compilação do projeto no Visual Studio Code.

Você verá que a pasta build foi criada novamente. Dentro dela, estarão os arquivos de compilação do projeto, e o executável oriented_graph gerado.

Executando

Com o projeto compilado, você pode executá-lo diretamente pelo VsCode. Clique no botão com o ícone de play na barra inferior do VsCode. Ele tem a função de Launch.

Você também pode acessar a mesma opção por meio da paleta de comandos do VsCode, pressionando Control + Shift + P Control + Shift + P e buscando por CMake: Run without Debugging.

Na seção de Terminal do VsCode, você verá a saída do programa oriented_graph, que foi executado.

Seção de Terminal do Visual Studio Code, em que se vê a saída do programa. — Saída do programa na seção de Terminal do Visual Studio Code.

Depurando

Para depurar o projeto, garanta que você tem a extensão CodeLLDB instalada. Por padrão, o VsCode tenta usar o depurador GDB para depuração. Dessa forma, a extensão faz a compatibilidade para usarmos o LLDB.

Nele, adicionamos uma nova configuração de depuração para rodar um programa sem antes compilá-lo (dado que o CMakeTools já fez isso). Também definimos algumas configurações específicas para o CMake. O nome dessa configuração é LLDB: launch C++ project.

Agora, adicione um ponto de depuração na linha 12 do arquivo main.cpp. Então, clique no botão com o ícone de besouro na barra inferior do VsCode. Ele tem a função de Debug.

Você também pode acessar a mesma opção por meio da paleta de comandos do VsCode, pressionando Control + Shift + P Control + Shift + P e buscando por CMake: Debug.

O VsCode abrirá um terminal externo e executará o programa oriented_graph em modo de depuração.

Tela de depuração do projeto no Visual Studio Code. O programa está parado na linha 12 do arquivo main.cpp. Na parte esquerda da tela, estão as variáveis do programa, e na parte inferior, o terminal de depuração. — Tela de depuração do projeto no Visual Studio Code.

Tarefa personalizada

Se você precisar customizar a configuração de depuração, como adicionar argumentos ou variáveis de ambiente, você pode fazer isso por meio do arquivo launch.json, que fica dentro da pasta .vscode do seu projeto.

1
mkdir -p .vscode
2
touch .vscode/launch.json

Use o snippet launch-json para inicializar o arquivo com o seguinte código.

1
{
2
  "configurations": [],
3
  "version": "0.2.0"
4
}

Então, dentro do vetor configurations, use o snippet cmake-launch para criar uma configuração de depuração personalizada.

O conteúdo do arquivo será como o seguinte.

1
{
2
  "configurations": [
3
    {
4
      "name": "LLDB: launch CMake project (Local)",
5
      "type": "lldb",
6
      "request": "launch",
7
      "program": "${command:cmake.launchTargetPath}",
8
      "args": [],
9
      "cwd": "${workspaceFolder}",
10
      "terminal": "console",
11
      "preLaunchTask": "CMake: build"
12
    }
13
  ],
14
  "version": "0.2.0"
15
}

A entrada preLaunchTask define qual tarefa de compilação deve ser executada antes de iniciar a depuração. A extensão CMake Tools define um conjunto de tarefas padrão, como a CMake: build, que usamos. Isso faz com que, antes de iniciar a depuração, o projeto seja compilado.

Configurar uma tarefa de execução personalizada tem outra vantagem. A interface de depuração comum do VSCode, que pode ser acessada por meio do atalho Control + Shift + D Control + Shift + D , passa a funcionar totalmente com o CMake. Dessa forma, você pode inclusive depurar o projeto com o atalho F5 F5 .