C O Editor do Guia

Em toda aula há caixas Experimente: um pequeno editor de código com um botão Rodar. Elas não são uma imitação: cada clique compila de verdade o seu código, com o compilador Clang funcionando dentro do navegador, e roda o programa gerado. Nesta aula você vai conhecer cada parte da caixa, entender o que aparece no terminal dela, aprender a digitar a entrada do programa, usar as abas e as missões, e saber em que o editor é diferente do gcc instalado no seu computador.

A ideia: um laboratório portátil

Na escola, o laboratório de ciências tem tudo pronto: você chega, faz o experimento e vai embora. O editor do guia é assim. O compilador fica guardado dentro da página, e o programa roda num "computador de mentirinha" que só existe enquanto a aba está aberta, com uma pasta da Ana (/home/ana). Nada do que você fizer ali toca no seu computador. Se algo der muito errado, recarregue a página.

Por baixo, é o Clang 22, do projeto LLVM, o mesmo compilador que você instalaria no seu computador, só que transformado em WebAssembly (um formato de programa que os navegadores executam quase tão rápido quanto um programa comum). Junto vem a biblioteca C (onde moram o printf, o scanf, o malloc…). O compilador faz as quatro etapas que você viu em Como o C Vira Programa: pré-processar, compilar, montar e ligar. O resultado é um programa WebAssembly, que o navegador roda em seguida.

As partes da caixa

Rode esta caixa e acompanhe a explicação abaixo dela:

#include <stdio.h>

int main(void) {
    printf("Olá, mundo!\n");
    printf("2 + 3 = %d\n", 2 + 3);
    return 0;
}

Aba

O nome do arquivo que você está editando, como programa.c. Algumas caixas têm várias abas (veja Várias abas).

Restaurar

Volta ao código original da aula, apagando as suas mudanças. Use sem medo: o original nunca se perde.

Editor

Clique e digite. Os números à esquerda são os números das linhas, os mesmos que as mensagens de erro citam.

Argumentos

Palavras que o programa recebe ao ser chamado, como no terminal (veja Argumentos). Quase sempre fica vazio.

▶ Rodar

Compila e roda. Enquanto o programa roda, o botão vira ■ Parar.

Terminal

Aparece depois de rodar, com o título Terminal — ana@notebook: ~: o comando de compilação, as mensagens do compilador, o comando que roda o programa, a saída e o código de saída.

Depois de rodar, o terminal da caixa mostra:

$ clang -std=c23 -Wall -Wextra programa.c -o programa
$ ./programa
Olá, mundo!
2 + 3 = 5
[código de saída: 0]

São exatamente os passos que você faria no terminal: compilar com o clang (com as mesmas opções que o guia usa com o gcc: -std=c23 -Wall -Wextra, explicadas em Compilar com gcc) e rodar com ./programa. Enquanto compila, aparece (compilando…). O [código de saída: 0] é o número que o main devolve com o return 0;: 0 quer dizer "terminou bem". No terminal de verdade, ele fica escondido, e você o vê com echo $?; o editor mostra sempre.

A primeira vez: o download do compilador

Na primeira vez que você clica em Rodar, o navegador baixa o compilador e a biblioteca C: cerca de 23 MB. Aparece uma barra com a mensagem Baixando o compilador C (≈ 23 MB, só na primeira vez)… e a porcentagem, depois Preparando o compilador…. Leva de alguns segundos a um minuto, conforme a internet. Depois disso:

• o navegador guarda tudo: nas outras caixas, nas outras aulas e nas próximas visitas não há download;
• cada compilação leva só uma fração de segundo;
• se a internet cair no meio do download, aparece Não consegui carregar o compilador: … seguido de "Confira a internet e clique em Rodar de novo".

Se você usa o celular com plano de dados, prefira o Wi-Fi na primeira vez.

Atalhos do editor

Erros e avisos de compilação

Quando o compilador reclama, as mensagens aparecem no terminal da caixa, coloridas como num terminal de verdade, e o programa não roda (não existe programa para rodar). A caixa abaixo tem um erro:

#include <stdio.h>

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

#include <stdio.h>

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

$ clang -std=c23 -Wall -Wextra programa.c -o programa
programa.c:4:29: error: expected ';' after expression
    4 |     printf("Olá, mundo!\n")
      |                            ^
      |                            ;
1 error generated.
[código de saída: 1]

A mensagem diz: no arquivo programa.c, linha 4, coluna 29, um error ("erro"): expected ';' after expression, "esperava ; depois da expressão". A setinha ^ aponta o lugar, e a linha de baixo mostra o ; que falta. O 1 error generated. conta os erros, e o [código de saída: 1] é o do compilador: deu errado, nada foi rodado. A aula Lendo Erros do Compilador ensina a ler essas mensagens.

Repare na solução: ela não tem return 0;. Desde o C99, o main (e só ele) pode terminar sem return, e devolve 0. O guia escreve o return 0; mesmo assim, para deixar claro.

Avisos (warning) são diferentes: o programa compila e roda, mas o compilador desconfia de algo. Os dois aparecem no terminal, um antes do outro:

$ clang -std=c23 -Wall -Wextra programa.c -o programa
programa.c:4:9: warning: unused variable 'idade' [-Wunused-variable]
    4 |     int idade = 29;
      |         ^~~~~
1 warning generated.
$ ./programa
Olá!
[código de saída: 0]

A variável idade foi criada e nunca usada: não é erro, mas costuma ser esquecimento. A aula Avisos (-Wall -Wextra) mostra os mais comuns.

A entrada: o programa pergunta, você responde

Quando um programa lê o teclado com scanf ou fgets (aulas Entrada com scanf e Ler uma Linha), a caixa pausa o programa e mostra um campo para você digitar, dentro do próprio terminal, logo depois da pergunta. Digite e tecle Enter. Rode e experimente:

#include <stdio.h>

int main(void) {
    char nome[50] = "";
    printf("Qual é o seu nome? ");
    scanf("%49s", nome);
    printf("Olá, %s!\n", nome);
    return 0;
}

Algumas caixas já trazem a entrada pronta, num campo Entrada ao lado do botão Rodar: o que estiver ali é entregue ao programa, uma linha de cada vez, como se alguém digitasse. No terminal da caixa, cada linha aparece no ponto em que o programa a lê. Você pode mudar o texto do campo antes de rodar.

#include <stdio.h>

int main(void) {
    char nome[50] = "";
    printf("Nome: ");
    scanf("%49s", nome);
    printf("Olá, %s!\n", nome);
    return 0;
}

#include <stdio.h>

int main(void) {
    char nome[50] = "";
    int idade = 0;
    printf("Nome: ");
    scanf("%49s", nome);
    printf("Idade: ");
    scanf("%d", &idade);
    printf("%s tem %d anos.\n", nome, idade);
    return 0;
}

Com a solução, o terminal da caixa mostra cada resposta logo depois da pergunta, como se a Ana tivesse digitado:

$ clang -std=c23 -Wall -Wextra programa.c -o programa
$ ./programa
Nome: Ana
Idade: 29
Ana tem 29 anos.
[código de saída: 0]

Repare que o printf("Nome: ") não tem \n, e mesmo assim a pergunta aparece antes de o programa esperar a resposta: quando o programa vai ler o teclado, o que estava esperando para ser mostrado aparece primeiro. É o que acontece no terminal do Linux também.

No terminal da Ana, a mesma ideia: quando o programa espera, o que ela digita aparece na tela (é o terminal que "ecoa" as teclas). Se a entrada vier de outro programa, pelo |, nada é ecoado, e a resposta sai grudada na pergunta:

$ echo Ana | ./nome
Qual é o seu nome? Olá, Ana!                       « o "Ana" veio pelo |, sem eco

Argumentos

O campo Argumentos faz o papel das palavras que vêm depois do nome do programa no terminal: ./programa maçã 'pera uva'. Aspas juntam palavras num argumento só, como no bash. O programa os recebe no argv (aula Argumentos da Linha de Comando):

#include <stdio.h>

int main(int argc, char *argv[]) {
    for (int i = 0; i < argc; i++) {
        printf("%d: %s\n", i, argv[i]);
    }
    return 0;
}

$ clang -std=c23 -Wall -Wextra programa.c -o programa
$ ./programa 'maçã' 'pera uva'
0: ./programa
1: maçã
2: pera uva
[código de saída: 0]

O argv[0] é sempre o próprio nome do programa. Na linha do comando, o editor põe aspas em volta de maçã por precaução (por causa das letras acentuadas); o programa recebe a palavra sem as aspas. Troque o texto do campo e rode de novo.

Várias abas: vários arquivos

Algumas caixas têm mais de uma aba. Cada aba é um arquivo da mesma pasta:

• todos os arquivos .c são compilados juntos num programa só (aula Vários Arquivos);
• os outros (.h, .txt, .csv) ficam na pasta em que o programa roda, /home/ana, e o programa pode abri-los com fopen;
• arquivos que o programa cria vivem numa pasta na memória, que começa limpa a cada Rodar.

#include <stdio.h>

int main(void) {
    FILE *arquivo = fopen("lista.txt", "r");
    if (arquivo == NULL) {
        perror("lista.txt");
        return 1;
    }
    char item[100];
    int n = 0;
    while (fgets(item, sizeof item, arquivo) != NULL) {
        n = n + 1;
        printf("%d. %s", n, item);
    }
    fclose(arquivo);
    return 0;
}

arroz
feijão
café

O programa abre o lista.txt da outra aba e numera as linhas (a aula Ler Arquivos explica cada linha). Clique na aba lista.txt, acrescente leite numa linha nova e rode outra vez. Repare também no comando de compilação: o executável se chama compras, o nome do primeiro .c sem a extensão. E troque "lista.txt" por "listas.txt": o perror mostra lista.txt: No such file or directory e o programa termina com o código 1.

Missões, Restaurar e Ver solução

Muitas caixas têm uma missão: um desafio escrito acima do editor. Embaixo da caixa aparece Missão em andamento…; a cada Rodar, o editor confere se o desafio foi cumprido e, quando foi, mostra ✔ Missão cumprida!. Se faltar alguma coisa, a mensagem dá uma pista entre parênteses, como (o código ainda não compila) ou (a saída ainda não é a esperada).

O editor confere o resultado, não o jeito: se a missão pede que apareça Olá, Ana!, qualquer código que mostre isso vale. Algumas missões pedem também um recurso (por exemplo, "use um for") ou um erro de propósito, para você ver a mensagem. Como esta:

#include <stdio.h>

int main(void) {
    printf("Vou dar erro de propósito\n");
    return 0;
}

#include <stdio.h>

int main(void) {
    printf("Vou dar erro de propósito\n")
    return 0;
}

Parar um programa

Um programa que não termina nunca (um "laço infinito", que você vai conhecer em while) não trava a página: ele roda separado. Clique em ■ Parar: aparece ^C e o código de saída 130. Se você não parar, o editor para sozinho depois de 15 segundos, com a mensagem (o editor parou o programa: ele rodou mais de 15 segundos sem terminar — laço infinito?). O tempo em que o programa espera você digitar não conta. E um programa que escreve demais (mais de 2 MB de texto) também é interrompido.

Clang no editor × gcc no terminal

As caixas usam o Clang; os terminais das aulas mostram o gcc. Os dois seguem o mesmo padrão C23, então um programa correto dá o mesmo resultado nos dois. A diferença aparece quando algo dá errado: cada compilador escreve as mensagens com as suas palavras. Debaixo de toda caixa há uma nota lembrando disso. Veja as mesmas falhas nos dois compiladores, todas reais (o Clang da Ana, versão 21, dá as mesmas mensagens que o Clang 22 do editor).

1. Faltou o ;

$ gcc -std=c23 -Wall -Wextra erro.c -o erro
erro.c: In function ‘main’:
erro.c:4:28: error: expected ‘;’ before ‘}’ token
    4 |     printf("Olá, mundo!\n")
      |                            ^
      |                            ;
    5 | }
      | ~
$ clang -std=c23 -Wall -Wextra erro.c -o erro
erro.c:4:29: error: expected ';' after expression
    4 |     printf("Olá, mundo!\n")
      |                            ^
      |                            ;
1 error generated.

O gcc diz "esperava ; antes do }"; o Clang, "esperava ; depois da expressão". Mesmo diagnóstico, mesmo conserto. Repare em três diferenças de estilo:

• o gcc começa dizendo em que função está (In function ‘main’);
• o gcc usa aspas curvas (‘;’), o Clang aspas retas (';');
• a coluna: 28 no gcc e 29 no Clang. O Clang conta bytes, e o á de "Olá" ocupa dois bytes em UTF-8 (aula Acentos e UTF-8); o gcc conta caracteres. Numa linha sem acentos, os dois dão o mesmo número.

2. Um nome que não existe

$ gcc -std=c23 -Wall -Wextra total.c -o total
total.c: In function ‘main’:
total.c:5:35: error: ‘quantidade’ undeclared (first use in this function)
    5 |     printf("Total: %d\n", preco * quantidade);
      |                                   ^~~~~~~~~~
total.c:5:35: note: each undeclared identifier is reported only once for each function it appears in
$ clang -std=c23 -Wall -Wextra total.c -o total
total.c:5:35: error: use of undeclared identifier 'quantidade'
    5 |     printf("Total: %d\n", preco * quantidade);
      |                                   ^~~~~~~~~~
1 error generated.

gcc: "quantidade não declarada (primeiro uso nesta função)", e uma nota: "cada identificador não declarado é avisado só uma vez por função". Clang: "uso de identificador não declarado quantidade". As duas querem dizer: você usou um nome que o programa não conhece (esqueceu de criar a variável, ou escreveu o nome diferente). Essa dupla de frases vai aparecer muito no guia.

3. Uma função que o compilador ainda não conhece

$ gcc -std=c23 -Wall -Wextra dobro.c -o dobro
dobro.c: In function ‘main’:
dobro.c:4:20: error: implicit declaration of function ‘dobro’ [-Wimplicit-function-declaration]
    4 |     printf("%d\n", dobro(21));
      |                    ^~~~~
$ clang -std=c23 -Wall -Wextra dobro.c -o dobro
dobro.c:4:20: error: use of undeclared identifier 'dobro'
    4 |     printf("%d\n", dobro(21));
      |                    ^~~~~
1 error generated.

O programa chama dobro antes de dizer o que ela é. O gcc fala em "declaração implícita da função" (um costume do C antigo, proibido desde o C99); o Clang, com -std=c23, trata como um nome qualquer que não existe. O conserto é declarar a função antes de usar (aula Protótipos).

4. Erro do ligador

$ gcc -std=c23 -Wall -Wextra soma.c -o soma
/usr/bin/x86_64-linux-gnu-ld.bfd: /tmp/cccJZCgy.o: na função "main":
soma.c:(.text+0x13): referência não definida para "soma"
collect2: error: ld returned 1 exit status

$ clang -std=c23 -Wall -Wextra programa.c -o programa
wasm-ld: error: /tmp/programa-62bf3f.o: undefined symbol: soma
clang: error: linker command failed with exit code 1 (use -v to see invocation)
[código de saída: 1]

A função soma foi declarada (int soma(int a, int b);) e nunca escrita (veja Como o C Vira Programa). No Linux, o ligador é o ld, e a mensagem sai em português ("referência não definida"; em inglês, nos fóruns, undefined reference to); no editor, o ligador é o wasm-ld (o ligador de WebAssembly), em inglês ("símbolo não definido"). Mesmo problema, mesma solução: escrever a função.

Quando uma mensagem de um não fizer sentido, compare com a do outro: muitas vezes uma explica melhor que a outra.

O que funciona no editor

• Todo o C23 que o guia ensina, inclusive as novidades: bool, nullptr, constexpr, typeof, 1'000'000, 0b1010, #embed (aula Novidades do C99 ao C23). Outras versões (-std=c17, -std=c11, -std=c99) quando a caixa pede.
• A biblioteca padrão: stdio.h, string.h, stdlib.h (malloc, free, qsort, rand…), ctype.h, math.h, time.h, stdint.h, assert.h, errno.h, setjmp.h, signal.h.
• Entrada (scanf, fgets, getchar), argumentos, arquivos das abas e arquivos criados pelo programa.
• O math.h funciona sem a opção -lm (no gcc, às vezes ela é necessária: veja a aula Matemática).
• Os erros "clássicos" quebram o programa como no Linux: ponteiro nulo dá Falha de segmentação (imagem do núcleo gravada) (código 139), divisão inteira por zero dá Exceção de ponto flutuante (imagem do núcleo gravada) (136), abort() e assert dão Abortado (imagem do núcleo gravada) (134), e uma recursão sem fim estoura a pilha (139).

O que não funciona (só no seu computador)

• Processos e threads: fork, exec, pthread. As aulas Processos e Threads usam o terminal.
• system() (rodar um comando do sistema) e rede: não há sistema nem rede dentro do navegador. system("ls") mostra sh: 1: ls: not found.
• Depurador e ferramentas de memória (gdb, valgrind, -fsanitize): as aulas Depurar com gdb, Valgrind e Sanitizers usam o terminal.
• Fuso horário: o relógio do editor está em UTC (horário de Greenwich), 3 horas à frente de Brasília.
• Limites: 15 segundos rodando, 2 MB de saída, 256 MB de memória (um malloc maior que isso devolve NULL).

O que é diferente no editor × no seu computador

O editor gera um programa WebAssembly de 32 bits e usa a biblioteca C wasi-libc (feita a partir da musl). O gcc do Linux gera um programa x86-64 de 64 bits e usa a glibc, a biblioteca C do projeto GNU. Para programas corretos, isso quase nunca muda nada. Mas, quando o programa faz algo errado ou depende do tamanho dos tipos, as diferenças aparecem. Todas as linhas abaixo foram conferidas: no editor, com a ferramenta do guia que roda o mesmo compilador fora do navegador; no computador, com o gcc 15 da Ana.

A lição mais importante está nas linhas do v[5] e do free duplo: um erro que "passa em silêncio" continua sendo um erro. Em C, ler fora do array ou liberar a memória duas vezes é comportamento indefinido: o programa pode travar, pode mostrar lixo, pode até parecer funcionar, e o resultado muda de um computador para outro. O editor e o gcc fizeram coisas diferentes justamente por isso. A aula Comportamento Indefinido trata do assunto, e as aulas Sanitizers e Valgrind mostram as ferramentas que caçam esses erros no seu computador.

Confira o tamanho dos tipos no editor. No terminal da Ana, o mesmo programa mostra int: 4, long: 8, long long: 8 e ponteiro: 8:

#include <stdio.h>

int main(void) {
    printf("int: %zu\n", sizeof(int));
    printf("long: %zu\n", sizeof(long));
    printf("long long: %zu\n", sizeof(long long));
    printf("ponteiro: %zu\n", sizeof(int *));
    return 0;
}

Por isso o guia prefere int e long long, que têm o mesmo tamanho nos dois, ou os tipos de tamanho fixo de stdint.h (int32_t, int64_t), e explica os tamanhos nas aulas Inteiros e Tamanho dos Tipos.

No terminal da Ana, os programas que "quebram" mostram estas mensagens (o bash escreve o nome do sinal e o do programa):

$ ./nulo
antes
Falha de segmentação     (imagem do núcleo gravada) ./nulo
$ ./divzero
antes
Exceção de ponto flutuante (imagem do núcleo gravada) ./divzero
$ ./freeduplo
free(): double free detected in tcache 2
Abortado                   (imagem do núcleo gravada) ./freeduplo

Quando dá errado

Referência

Exercícios

Missão final: o código de saída

#include <stdio.h>

int main(void) {
    printf("Tudo certo.\n");
    return 0;
}

#include <stdio.h>

int main(void) {
    printf("Arquivo não encontrado.\n");
    return 3;
}

No terminal da Ana, o código aparece com echo $?:

$ ./saida
Arquivo não encontrado.
$ echo $?
3

Resumo

• As caixas Experimente compilam C de verdade com o Clang 22 em WebAssembly, no navegador, com -std=c23 -Wall -Wextra, e rodam o programa.
• Na primeira vez, o navegador baixa uns 23 MB; depois, fica guardado.
• O terminal da caixa mostra o comando, os erros e avisos, a saída e o [código de saída: N].
• scanf, fgets, getchar: o programa pausa e você digita no terminal da caixa (Enter envia, Ctrl+D encerra, Ctrl+C para). Argumentos e abas funcionam como no terminal.
• Missões conferem o resultado; Restaurar volta ao original; Ver solução mostra uma solução.
• Clang e gcc dizem a mesma coisa com palavras diferentes: use of undeclared identifier × undeclared (first use in this function). Leia sempre a primeira mensagem.
• Diferenças: long e ponteiros têm 4 bytes no editor e 8 no Linux; rand() e %p dão outros números; threads, system(), gdb, valgrind e sanitizers só no seu computador; erros de memória podem passar em silêncio no editor.
• Próximo passo: o seu primeiro programa, linha por linha, em Olá, Mundo.