C Editores e IDEs

Código C é texto puro: dá para escrevê-lo até no Bloco de Notas. Mas um bom editor de código faz a diferença entre sofrer e aprender: ele pinta cada parte do código de uma cor, marca o erro enquanto você digita, completa nomes e compila com uma tecla. Nesta aula você vai conhecer os editores e IDEs mais usados para C, configurar o VS Code para o C23, compilar por dentro dele e aprender os cuidados com o arquivo que evitam muita dor de cabeça.

Esta aula não tem capturas de tela: os menus mudam a cada versão, e o guia descreve o caminho pelo nome dos botões. As saídas de terminal foram produzidas na máquina fictícia da Ana, com o gcc 15.2, na pasta ~/c.

A ideia: caneta, caderno e estojo completo

1. Por que um editor de código ajuda tanto

Veja um engano que todo iniciante comete: esquecer de fechar as aspas. A Ana escreveu "Olá, mundo!\n e o " do fim sumiu:

#include <stdio.h>

int main(void) {
    printf("Olá, mundo!\n);
    printf("Tchau!\n");
    return 0;
}

Num editor de código, o problema salta aos olhos antes mesmo de compilar: o texto entre aspas tem uma cor própria, e essa cor "vaza" até o fim da linha, ou as aspas da linha seguinte ficam com a cor trocada. O editor também sublinha o erro com uma ondinha vermelha. Sem essa ajuda, a Ana só descobre ao compilar, e o gcc responde com uma avalanche:

$ gcc -std=c23 -Wall -Wextra aspas.c -o aspas 2>&1 | wc -l
32                                                   « 32 linhas de mensagens!
$ gcc -std=c23 -Wall -Wextra aspas.c -o aspas 2>&1 | head -6
aspas.c: In function ‘main’:
aspas.c:4:12: warning: missing terminating " character
    4 |     printf("Olá, mundo!\n);
      |            ^
aspas.c:4:12: error: missing terminating " character   « a primeira mensagem diz tudo
    4 |     printf("Olá, mundo!\n);

2>&1

As mensagens do compilador saem por um "canal" separado da saída normal (o stderr, aula stdin, stdout e stderr). O 2>&1 junta os dois canais, para o próximo comando receber tudo.

| wc -l

O | (barra vertical, o "cano") entrega a saída para outro comando. O wc -l conta as linhas: 32.

| head -6

Mostra só as seis primeiras linhas.

A primeira mensagem já diz o problema: missing terminating " character, "falta o caractere " de fechamento", na linha 4, coluna 12. As outras linhas são consequência: sem as aspas fechadas, o gcc se perdeu e tentou entender o resto de todo jeito, reclamando de coisas que estão certas. Regra de ouro, que a aula Lendo Erros do Compilador detalha: leia e conserte a primeira mensagem, e compile de novo.

O editor do guia também pinta o código. Repare nas cores da linha 4 e no que o compilador dele, o Clang, responde: missing terminating '"' character e expected expression ("esperava uma expressão"):

#include <stdio.h>

int main(void) {
    printf("Olá, mundo!\n);
    printf("Tchau!\n");
    return 0;
}

#include <stdio.h>

int main(void) {
    printf("Olá, mundo!\n");
    printf("Tchau!\n");
    return 0;
}

Além das cores, um editor de código:

• numera as linhas, os mesmos números que as mensagens do compilador citam (aspas.c:4:12 é a linha 4, coluna 12);
• faz o recuo sozinho: depois de um {, a próxima linha já começa mais para dentro;
• fecha os pares: digitou (, ele põe o ); digitou ", ele põe o outro ";
• completa nomes: digite pri e ele sugere printf;
• marca erros e avisos enquanto você digita, antes de compilar.

2. VS Code

O Visual Studio Code (VS Code) é um editor de código gratuito da Microsoft, para Windows, Linux e macOS. Sozinho, ele só pinta o código; com as extensões certas, vira um ambiente completo para C. É o editor mais usado do mundo e o recomendado para seguir o guia. Não confunda com o Visual Studio (sem "Code"), a IDE pesada só para Windows (seção 3).

Instalando

1. Baixe em code.visualstudio.com: no Ubuntu e no Debian, o arquivo .deb; no Fedora, o .rpm; no Windows e no macOS, o instalador.
2. Instale como qualquer programa. No Ubuntu, dê dois cliques no .deb ou rode sudo apt install ./code_*.deb na pasta do download.
3. Abra a pasta dos seus programas: no terminal, code ~/c; ou, no VS Code, Arquivo → Abrir Pasta. Trabalhe sempre com a pasta aberta, não com arquivos soltos: as configurações e as tarefas ficam guardadas na pasta.
4. Crie um arquivo com Arquivo → Novo Arquivo e salve com um nome terminado em .c, como ola.c. Na hora, o VS Code reconhece a linguagem (o canto de baixo da janela passa a dizer C) e oferece instalar a extensão de C.

As extensões: C/C++ ou clangd

Abra a aba Extensões (o ícone de quadradinhos na barra da esquerda, ou Ctrl+Shift+X) e procure pelo nome. Há duas boas opções, e você deve usar uma delas. Apesar do nome "C/C++" e do "clang" no nome da outra, as duas servem para C:

Pelo terminal, a instalação é um comando: code --install-extension ms-vscode.cpptools (ou o identificador do clangd). Se instalar as duas, a do clangd pergunta se pode desligar o IntelliSense da Microsoft: aceite, senão cada erro aparece duas vezes. Dá para manter a da Microsoft só para depurar.

Configurando o C23

Os dois "corretores" precisam saber que você usa o C23. Senão, analisam o código como se fosse de uma versão antiga e sublinham em vermelho coisas novas, como bool sem #include ou nullptr, mesmo o programa compilando (veja "Quando dá errado").

• Na extensão C/C++: abra as configurações (Ctrl+,), procure C Standard e escolha c23 no item C_Cpp › Default: C Standard. (O item vizinho, Cpp Standard, é para C++: não precisa mexer.)
• No clangd: crie na pasta do projeto um arquivo chamado compile_flags.txt com as opções de compilação, uma por linha:

-std=c23
-Wall
-Wextra

O clangd lê esse arquivo e passa a analisar o código com as mesmas opções do comando padrão do guia (aula Compilar com gcc). Em projetos com CMake, ele usa outro arquivo, gerado automaticamente (aula CMake).

Compilar pelo terminal integrado

O VS Code tem um terminal dentro dele: menu Terminal → Novo Terminal (ou Ctrl+'). Ele abre já na pasta do projeto. É o jeito mais simples e o que o guia recomenda no começo, porque você vê o comando e a saída completos, iguais aos das aulas:

$ gcc -std=c23 -Wall -Wextra ola.c -o ola
$ ./ola
Olá, mundo!

Quando há erro, segure Ctrl e clique no aspas.c:4:12 da mensagem: o VS Code abre o arquivo exatamente na linha e na coluna do problema.

Compilar com uma tecla: o tasks.json

Digitar o comando toda vez cansa. O VS Code permite gravar um comando como uma tarefa (task), num arquivo chamado tasks.json, dentro de uma pasta .vscode no projeto. Crie .vscode/tasks.json com este conteúdo:

{
  "version": "2.0.0",
  "tasks": [
    {
      "label": "Compilar C23",
      "type": "shell",
      "command": "gcc",
      "args": [
        "-std=c23", "-Wall", "-Wextra", "-g",
        "${file}",
        "-o", "${fileDirname}/${fileBasenameNoExtension}"
      ],
      "problemMatcher": ["$gcc"],
      "group": { "kind": "build", "isDefault": true }
    }
  ]
}

Agora, com o ola.c aberto, tecle Ctrl+Shift+B. O VS Code abre o terminal e executa o comando montado com as variáveis. Na máquina da Ana, ele fica assim (rodado à mão, o resultado é o mesmo):

$ gcc -std=c23 -Wall -Wextra -g /home/ana/c/ola.c -o /home/ana/c/ola
$ ./ola
Olá, mundo!

A tarefa compila; para rodar, use o terminal (./ola). A extensão C/C++ também tem um botão ▷ no canto da aba, que cria uma configuração própria na primeira vez (ela pergunta qual compilador usar). Ele funciona, mas a configuração que ele gera não tem -std=c23 nem -Wall -Wextra: se for usá-lo, acrescente essas opções na lista args do tasks.json que ele criar.

$ gcc idade.c -o idade && ./idade                « o comando do Code Runner
Olá, Ana!                                         « nenhum aviso
$ gcc -std=c23 -Wall -Wextra idade.c -o idade     « o comando do guia
idade.c: In function ‘main’:
idade.c:4:9: warning: unused variable ‘idade’ [-Wunused-variable]
    4 |     int idade = 29;
      |         ^~~~~

3. Outras opções

CLion

O CLion, da JetBrains, é uma IDE feita só para C e C++, para Windows, Linux e macOS. Desde 2025, é gratuito para uso não comercial (estudar, projetos pessoais). Ele organiza tudo com o CMake: ao criar um projeto, escolha C Executable e o padrão C23, e ele grava set(CMAKE_C_STANDARD 23) no arquivo CMakeLists.txt (aula CMake). Tem análise de código muito boa (baseada no clangd), refatoração (renomear uma variável em todo o projeto de uma vez) e depurador visual. No Windows, já vem com um compilador (MinGW). É a melhor escolha para quem quer uma IDE completa sem ficar preso ao Windows. Lembre-se de que o CMake não liga o -Wall -Wextra sozinho: a aula de CMake mostra como.

Visual Studio

O Visual Studio (a edição Community é gratuita) é a IDE da Microsoft, só para Windows. Vem com o compilador MSVC e um ótimo depurador visual. Mas o MSVC foi feito pensando em C++: o C23 ainda está chegando a ele aos poucos, e as mensagens de erro são bem diferentes das do gcc mostradas no guia. A instalação, e como criar um arquivo .c nele, estão em Instalar no Windows e macOS. Para seguir este guia, prefira o VS Code com o gcc.

Code::Blocks

O Code::Blocks é uma IDE gratuita, leve e simples, muito usada em escolas e faculdades. No Windows, baixe a versão do instalador com mingw no nome, que já traz o gcc. No Linux: sudo apt install codeblocks.

1. Crie um projeto com File → New → Project → Console application e escolha C (não C++) quando ele perguntar a linguagem.
2. Em Settings → Compiler → Compiler settings, na aba Other compiler options, escreva -std=c23 -Wall -Wextra.
3. Compile e rode com F9.

Se o gcc que veio junto for antigo (até a versão 13), ele não conhece -std=c23: use -std=c2x, o nome antigo do C23 (aula Versões do C). A interface é mais antiga e o autocompletar é mais fraco, mas roda bem em computadores modestos. O Dev-C++, que muitas escolas ainda usam, é parecido, mas traz um gcc bem mais antigo, que não conhece boa parte do C23.

Vim e Neovim

O Vim e o Neovim são editores de terminal, rapidíssimos, que se usam só com o teclado. A curva de aprendizado é íngreme (o famoso "como eu saio do Vim?": tecle Esc e digite :q), mas quem aprende não larga. Dentro do Vim, dá para compilar e rodar sem sair do editor:

:w
:!gcc -std=c23 -Wall -Wextra % -o %:r
:!./%:r

:w

Salva o arquivo (write). Sem isso, o gcc compila a versão antiga, a que está no disco.

:!

Roda um comando do terminal sem sair do Vim.

%

O Vim troca pelo nome do arquivo aberto: ola.c.

%:r

O nome sem a extensão (root, "raiz"): ola.

O Neovim (e o Vim, com um plugin) conversa com o clangd e ganha autocompletar e erros sublinhados, como o VS Code. Para escrever rápido no terminal sem aprender o Vim, o nano também serve: ele mostra os atalhos no rodapé (Ctrl+O salva, Ctrl+X sai).

Qual escolher?

A escolha do editor não é para sempre, e não muda nada no código: um ola.c escrito no Vim compila igual a um escrito no CLion.

4. Os cuidados com o arquivo

A extensão .c

Salve com a extensão .c. É ela que faz o editor ligar as cores e as ferramentas de C, e que faz o gcc tratar o arquivo como código C. Dois enganos comuns:

1. O Bloco de Notas do Windows acrescenta .txt e o arquivo vira ola.c.txt. O gcc não reconhece a extensão e entrega o arquivo para o ligador, que não entende nada:

$ gcc -std=c23 -Wall -Wextra ola.c.txt -o ola
/usr/bin/x86_64-linux-gnu-ld.bfd:ola.c.txt: file format not recognized; treating as linker script
/usr/bin/x86_64-linux-gnu-ld.bfd:ola.c.txt:3: syntax error
collect2: error: ld returned 1 exit status

"Formato de arquivo não reconhecido; tratando como script do ligador", e logo depois "erro de sintaxe" na linha 3. No Windows, ative Exibir → Extensões de nomes de arquivos no Explorador de Arquivos para ver o nome completo, e renomeie para ola.c.

2. Salvar como .cpp (a extensão do C++). O gcc passa a compilar o arquivo como C++, uma linguagem parecida, mas diferente. Este programa é C correto (new é um nome qualquer em C), e falha como .cpp, porque em C++ new é uma palavra reservada:

$ gcc -std=c23 -Wall -Wextra turma.c -o turma && ./turma
A turma tem 30 alunos.
$ cp turma.c turma.cpp
$ gcc -std=c23 -Wall -Wextra turma.cpp -o turma
cc1plus: warning: command-line option ‘-std=c23’ is valid for C/ObjC but not for C++
turma.cpp: In function ‘int main()’:
turma.cpp:4:9: error: expected unqualified-id before ‘new’
    4 |     int new = 30;
      |         ^~~
turma.cpp:5:43: error: expected type-specifier before ‘)’ token
    5 |     printf("A turma tem %d alunos.\n", new);
      |                                           ^

A primeira linha entrega o que aconteceu: cc1plus é o compilador de C++ do gcc, e ele avisa que "-std=c23 vale para C, mas não para C++". Se aparecer cc1plus ou int main() numa mensagem sua, confira a extensão do arquivo.

Codificação: UTF-8

Os acentos do guia ("Olá", "feijão") só funcionam direito se o arquivo for salvo em UTF-8, a codificação usada pelo Linux, pelo macOS e pela web. O VS Code, o CLion e o Vim usam UTF-8 por padrão; no VS Code, a codificação aparece na barra de status, no canto de baixo. A aula Acentos e UTF-8 explica o que acontece quando não é.

Salve antes de compilar

O compilador lê o arquivo do disco, não o que está na tela do editor. Se você mudou o código e não salvou, o gcc compila a versão anterior, e parece que "a mudança não funcionou". No VS Code, uma bolinha branca na aba indica arquivo não salvo. Dica: ative Arquivo → Salvamento Automático. (O editor do guia não tem esse problema: o Rodar sempre compila o que está na caixa.)

Quando dá errado

$ gcc -std=c23 -Wall -Wextra nulo.c -o nulo && ./nulo
Tudo certo.
$ gcc -std=c17 -Wall -Wextra nulo.c -o nulo
nulo.c: In function ‘main’:
nulo.c:4:5: error: unknown type name ‘bool’
    4 |     bool pronto = true;
      |     ^~~~
nulo.c:2:1: note: ‘bool’ is defined in header ‘<stdbool.h>’; this is probably fixable by adding ‘#include <stdbool.h>’
    1 | #include <stdio.h>
  +++ |+#include <stdbool.h>
    2 |
nulo.c:4:19: error: ‘true’ undeclared (first use in this function)
    4 |     bool pronto = true;
      |                   ^~~~
nulo.c:4:19: note: ‘true’ is defined in header ‘<stdbool.h>’; this is probably fixable by adding ‘#include <stdbool.h>’
nulo.c:4:19: note: each undeclared identifier is reported only once for each function it appears in
nulo.c:5:14: error: ‘nullptr’ undeclared (first use in this function)
    5 |     int *p = nullptr;
      |              ^~~~~~~

$ gcc -std=c23 -Wall -Wextra -g .vscode/tasks.json -o .vscode/tasks
/usr/bin/x86_64-linux-gnu-ld.bfd:.vscode/tasks.json: file format not recognized; treating as linker script
/usr/bin/x86_64-linux-gnu-ld.bfd:.vscode/tasks.json:1: syntax error
collect2: error: ld returned 1 exit status

Referência: atalhos do VS Code

Exercícios

Missão final: o recuo que ajuda a ler

#include <stdio.h>

int main(void) {
printf("Lista de compras:\n");
printf("- arroz\n");
printf("- feijão\n");
printf("- café\n");
return 0;
}

#include <stdio.h>

int main(void) {
    printf("Lista de compras:\n");
    printf("- arroz\n");
    printf("- feijão\n");
    printf("- café\n");
    return 0;
}

Para o compilador, os espaços no começo da linha não fazem diferença nenhuma; para quem lê, fazem toda. A aula Sintaxe mostra as convenções de recuo, e o atalho Shift+Alt+F do VS Code faz isso automaticamente.

Resumo

• Editor de texto escreve; editor de código ajuda (cores, recuo, autocompletar, erros marcados); IDE integra tudo. Nenhum deles é o compilador.
• VS Code (recomendado): extensão C/C++ (ms-vscode.cpptools) ou clangd; configure o C23 (C_Cpp.default.cStandard = c23 ou compile_flags.txt com -std=c23).
• Compile pelo terminal integrado ou com um .vscode/tasks.json e Ctrl+Shift+B, sempre com -std=c23 -Wall -Wextra. Fuja de botões que compilam sem avisos.
• CLion (IDE completa, grátis para uso não comercial), Visual Studio (Windows, C23 incompleto), Code::Blocks (leve, use -std=c2x se o gcc for antigo), Vim/Neovim (terminal).
• Arquivo com extensão .c (não .c.txt, nem .cpp), em UTF-8, e salvo antes de compilar.
• Diante de muitas mensagens de erro, leia a primeira.
• Próximo passo: conhecer a fundo as caixas Experimente, em O Editor do Guia.