Configurando o Visual Studio Code

Para compilar e executar programas em C no Visual Studio Code, devemos instalar algumas extensões. Recomendamos criar um perfil para o C e C++, o que manterá as configurações para essas linguagens separadas.

Perfil

Para criar um perfil no Visual Studio Code, clique no ícone de engrenagem no canto inferior esquerdo e selecione Profiles (ou perfis).

Abrindo a tela de configuração de perfis do Visual Studio Code.

Clique no botão New Profile. Uma nova entrada surgirá na lista de perfis.

Dê um nome ao perfil, como C/C++. Escolha o ícone de sua preferências.

Criando um novo perfil chamado "C/C++".

Agora, selecione o perfil ao clicar no ícone de check ao lado da entrada dele na lista de perfis.

Selecionando o perfil "C/C++".

Cuidado

lembre-se de sempre selecionar este perfil ao abrir o Visual Studio Code em um projeto de C ou C++, para que as configurações sejam aplicadas.

Extensões

Tendo ativado o perfil C/C++, instale as seguinte extensões no Visual Studio Code:

• Git Graph: visualiza o histórico de commits do Git;
• C/C++: fornece suporte para desenvolvimento em C e C++;
• clangd: fornece recursos de análise de código para o Clang;
• CodeLLDB: permite a depuração de programas em C e C++.

Se você estiver usando o WSL, certifique-se de clicar nos botões Install in WSL: Ubuntu para cada extensão da lista de instaladas que oferecer essa opção.

Configurações

Vamos adicionar algumas configurações padrão para o perfil C/C++.

Abra a paleta de comandos do Visual Studio Code com Ctrl + Shift + P e pesquise por Preferences: Open User Settings (JSON), ou o equivalente em português.

Isso abrirá um arquivo chamado settings.json, responsável por definir as configurações desse perfil. Toda vez que você muda alguma opção no menu de configurações do Visual Studio Code, o que ele faz é adicionar ou modificar uma linha nesse arquivo por baixo dos panos.

Copie o conteúdo a seguir e cole no arquivo settings.json aberto.

{
  "C_Cpp.default.cStandard": "c23",
  "C_Cpp.default.cppStandard": "c++23",
  "C_Cpp.default.includePath": ["${workspaceFolder}/**"],
  "C_Cpp.default.intelliSenseMode": "clang-x64",
  "C_Cpp.intelliSenseEngine": "disabled",
  "[css]": {
    "editor.defaultFormatter": "esbenp.prettier-vscode"
  },
  "[html]": {
    "editor.defaultFormatter": "esbenp.prettier-vscode"
  },
  "[javascript]": {
    "editor.defaultFormatter": "esbenp.prettier-vscode"
  },
  "[json]": {
    "editor.defaultFormatter": "esbenp.prettier-vscode",
    "editor.tabSize": 2
  },
  "[jsonc]": {
    "editor.defaultFormatter": "esbenp.prettier-vscode",
    "editor.tabSize": 2
  },
  "[markdown]": {
    "editor.defaultFormatter": "DavidAnson.vscode-markdownlint",
    "editor.formatOnPaste": true,
    "editor.formatOnSave": true,
    "editor.tabSize": 2,
    "prettier.tabWidth": 2
  },
  "editor.formatOnSave": true,
  "editor.inlineSuggest.enabled": true,
  "editor.semanticHighlighting.enabled": true,
  "files.eol": "\n",
  "files.insertFinalNewline": true,
  "files.trimFinalNewlines": true,
  "git.autofetch": true,
  "git.openRepositoryInParentFolders": "always",
  "security.allowedUNCHosts": ["wsl$", "wsl.localhost"]
}

Perceba que, abrindo o arquivo settings.json quando se usa o perfil C/C++, você verá as configurações específicas para este perfil, e não as configurações gerais do Visual Studio Code. É este mesmo o objetivo que temos.

A configuração definida no arquivo settings.json faz o seguinte:

• O compilador Clang é definido como o compilador padrão;
• Ativamos o IntelliSense para o Clang;
• As versões do C e do C++ são definidas como C23 e C++23, respectivamente;
• Definimos o formatador padrão como a extensão clangd, e desativamos a formatação da extensão C/C++;
• Entre outras definições úteis.

Salve o arquivo e feche o Visual Studio Code.

Dica

Caso você venha a precisar compilar um projeto para uma versão mais velha que a 23, basta alterar o valor das chaves C_Cpp.default.cStandard e C_Cpp.default.cppStandard para a versão desejada.

Snippets

Snippets são trechos de código que podem ser inseridos rapidamente no editor. Eles possuem um atalho que, ao ser digitado e pressionado Tab, expande o trecho para o código completo.

Estamos utilizando o clang-format como formatador de texto e o clang-tidy como linter. Para configurá-los, basta criar um arquivo .clang-format e um .clang-tidy na raiz do projeto.

Entretanto, criar e configurar esses arquivos manualmente pode ser trabalhoso. Por isso, podemos utilizar um snippet para criar esses arquivos automaticamente.

Garanta que você tenha selecionado o perfil C/C++. Então abra a paleta de comandos do Visual Studio Code com Ctrl + Shift + P e pesquise por Snippets: Configure Snippets.

Abrindo a configuração de snippets do Visual Studio Code.

Selecione a opção New Global Snippets file.

Criando um novo arquivo de snippets.

Digite o nome global e pressione Enter.

Nomeando o arquivo de snippets como "global".

O arquivo de configuração de snippets para o perfil C/C++ será aberto. Seu nome é global.code-snippets. Este é o conteúdo padrão dele:

Conteúdo padrão do arquivo de snippets "global".

Apague todo o conteúdo dele. Em seguida, acesse o arquivo global.code-snippets no repositório do livro. Copie o conteúdo do arquivo remote e cole no arquivo local que foi aberto no Visual Studio Code. Lembre-se de salvar após a edição.

Para usar os snippets, feche e abra o Visual Studio Code.

Então, abra o diretório separate_function que criamos anteriormente. Crie um arquivo chamado .clang-format e outro chamado .clang-tidy na raiz do projeto.

Em seguida, abra o arquivo .clang-format, digite clang-format e pressione Enter.

Utilizando o snippet "clang-format".

O arquivo .clang-format será preenchido com as configurações definidas no snippet Clang Format configurations.

Arquivo ".clang-format" preenchido com as configurações do snippet.

Agora, faça o mesmo para o arquivo .clang-tidy.

Dica

Caso deseje alterar as configurações do arquivo .clang-format, basta editá-lo. O LLVM disponibiliza a documentação acerca das opções de formatação. Igualmente, está disponível a documentação do Clang Tidy.

Projeto

Vamos criar um projeto para construir uma lista encadeada de nós.

No terminal, navegue para a pasta c_cpp_projects que criamos anteriormente.

cd ~/dev/c_cpp_projects

Crie um diretório chamado linked_nodes e navegue para dentro dele.

mkdir linked_nodes
cd linked_nodes

Abra o Visual Studio Code no diretório atual.

code .

Selecione o perfil C/C++ que criamos anteriormente.

Arquivos

Crie um arquivo chamado node.h e cole o seguinte código nele.

#ifndef __NODE_H__
#define __NODE_H__

struct Node {
        int data;
        struct Node *next;
};

struct Node *createNode();
void setData(struct Node *node, int data);
int getData(struct Node *node);
void setNext(struct Node *node, struct Node *next);
struct Node *getNext(struct Node *node);

#endif  // __NODE_H__

Então, crie um arquivo chamado node.c e cole o código a seguir.

#include "node.h"

#include <stdio.h>
#include <stdlib.h>

struct Node *createNode() {
    struct Node *new_node = (struct Node *) malloc(sizeof(struct Node));
    if (new_node != NULL) {
        new_node->data = 0;
        new_node->next = NULL;
    }
    return new_node;
}

void setData(struct Node *node, int data) {
    if (node != NULL) {
        node->data = data;
    }
}

int getData(struct Node *node) {
    if (node != NULL) {
        return node->data;
    }
    return -1;
}

void setNext(struct Node *node, struct Node *next) {
    if (node != NULL) {
        node->next = next;
    }
}

struct Node *getNext(struct Node *node) {
    if (node != NULL) {
        return node->next;
    }
    return NULL;
}

Por fim, crie um arquivo chamado main. e cole o código a seguir.

#include <stdio.h>
#include <stdlib.h>

#include "node.h"

int main() {
    printf("Creating a linked list with 10 nodes\n");

    struct Node *node = createNode();
    struct Node *head = node;
    setData(node, 1);

    for (int i = 2; i <= 10; i++) {
        struct Node *new_node = createNode();
        setData(new_node, i);
        setNext(node, new_node);
        node = new_node;
    }

    printf("Traversing the linked list\n");

    node = head;

    while (node != NULL) {
        printf("%d\t", getData(node));
        node = getNext(node);
    }

    printf("\n");

    return 0;
}

Você também pode acessar esse projeto no repositório do livro.

Para configurar a formatação e o linter, crie os arquivos .clang-format e .clang-tidy na raiz do projeto. Então utilize os snippets clang-format e clang-tidy para preenchê-los.

Compilação

Você verá que o Visual Studio Code já reconhece o projeto e identifica as bibliotecas e funções utilizadas.

Vamos compilar o projeto pelo terminal integrado do Visual Studio Code. Abra o terminal integrado com Ctrl + ` e execute o comando abaixo.

clang main.c node.c -include node.h -o linked_nodes

Esse comando compila os arquivos main.c e node.c, incluindo o arquivo de cabeçalho node.h, e gera o arquivo executável linked_nodes. Para executar o programa, digite ./linked_nodes e pressione Enter.

Compilação e execução do projeto "linked_nodes".

Agora, em vez de rodar o comando no terminal, vamos utilizar a interface gráfica do Visual Studio Code para compilar o projeto.

Crie uma pasta chamada .vscode na raiz do projeto. Ela é responsável por guardar configurações específicas do Visual Studio Code para o projeto.

Dentro dela, crie um arquivo chamado tasks.json e copie para ele o conteúdo do arquivo tasks.json do repositório do livro.

O que o arquivo faz é definir uma tarefa chamada Clang: build C project (all files in root) para o Linux e outra para o Windows. Essa tarefa compila o projeto com o Clang, incluindo todos os arquivos de cabeçalho e todos os arquivos de código definidos na raiz do projeto. O executável gerado terá o nome da pasta aberta no Visual Studio Code.

Clique no arquivo main.c no Visual Studio Code para focar a visualização nele.

Abra a paleta de comandos com Ctrl + Shift + P e pesquise por Tasks: Run Task. Você também pode executar esse comando com o atalho Ctrl + Shift + B.

Selecionando a opção de executar tarefa de compilação no Visual Studio Code.

Seleciona a tarefa Clang: build C project (all files in root) de acordo com o seu sistema operacional.

Selecionando a tarefa de compilação do projeto.

O mesmo comando de compilação será executado, mas pelo Visual Studio Code. Ele exibirá o resultado da compilação no terminal integrado.

Saída da compilação do projeto "linked_nodes".

Para executar, podemos chamar o arquivo executável diretamente no terminal integrado.

Neste caso, digite ./linked_nodes e pressione Enter.

Configurações

Felizmente, o Visual Studio Code permite que você salve as configurações de compilação em arquivos globais para serem utilizadas em outros projetos.

Ative o perfil C/C++, para que as configurações sejam salvas apenas para esse perfil. Dessa forma, eliminamos o risco de conflitos entre diferentes configurações de compilação e depuração.

Para salvar as tarefas de compilação, abra a paleta de comandos com Ctrl + Shift + P e pesquise por Tasks: Open User Tasks.

Abrindo o arquivo de tarefas do usuário.

Selecione a opção Others.

Selecionando a opção "Others".

Será aberto o arquivo padrão de tarefas do perfil C/C++.

Conteúdo do arquivo de tarefas do perfil "C/C++".

Copie o conteúdo do arquivo tasks.json do repositório do livro e cole no arquivo tasks.json aberto no Visual Studio Code. Lembre-se de salvar.

Assim, a tarefa estará disponível para todos os projetos que utilizarem o perfil C/C++.

Cuidado

Essa tarefa de compilação é específica para projetos que possuem todos os arquivos de código-fonte na raiz do projeto. Caso você tenha uma estrutura de pastas diferente, será necessário criar um arquivo na pasta .vscode de cada projeto com a tarefa de compilação específica. Então, você deve editar o comando definido no arquivo para especificar os arquivos de entrada.

Se você estiver desenvolvendo um projeto com outras pessoas que não fizeram a mesma configuração que você, então recomendo criar o arquivo tasks.json na pasta .vscode mesmo, para que elas possam compilar o projeto sem problemas.

Os arquivos modificados do perfil do Visual Studio Code ficarão como no repositório do livro.