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 compilador 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). Ele 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 <iostream>

int main() {
    std::cout << "Olá, mundo!\n";
    std::cout << "2 + 3 = " << 2 + 3 << "\n";
}

Aba

O nome do arquivo que você está editando, como programa.cpp. 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=c++23 -Wall -Wextra programa.cpp -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 g++: -std=c++23 -Wall -Wextra) e rodar com ./programa. Enquanto compila, aparece (compilando…). O [código de saída: 0] é o número que o programa devolve ao terminar: 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 padrão do C++: cerca de 33 MB. Aparece uma barra com a mensagem Baixando o compilador C++ (≈ 33 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 menos de um segundo para programas que começam com #include <iostream> ou #include <print> (esses cabeçalhos vêm "pré-compilados"), e de 2 a 5 segundos para os outros;
• 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. E repare na comparação: um compilador C++ instalado no computador ocupa centenas de megabytes; o do guia cabe em 33.

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 <iostream>

int main() {
    std::cout << "Olá, mundo!\n"
}

#include <iostream>

int main() {
    std::cout << "Olá, mundo!\n";
}

$ clang++ -std=c++23 -Wall -Wextra programa.cpp -o programa
programa.cpp:4:34: error: expected ';' after expression
    4 |     std::cout << "Olá, mundo!\n"
      |                                 ^
      |                                 ;
1 error generated.
[código de saída: 1]

A mensagem diz: no arquivo programa.cpp, linha 4, coluna 34, 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.

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=c++23 -Wall -Wextra programa.cpp -o programa
programa.cpp: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 mostra os mais comuns.

A entrada: o programa pergunta, você responde

Quando um programa lê o teclado com std::cin (aula Entrada com cin), 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 <iostream>
#include <string>

int main() {
    std::string nome;
    std::cout << "Qual é o seu nome? ";
    std::cin >> nome;
    std::cout << "Olá, " << nome << "!\n";
}

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 <iostream>
#include <string>

int main() {
    std::string nome;
    std::cout << "Nome: ";
    std::cin >> nome;
    std::cout << "Olá, " << nome << "!\n";
}

#include <iostream>
#include <string>

int main() {
    std::string nome;
    int idade = 0;
    std::cout << "Nome: ";
    std::cin >> nome;
    std::cout << "Idade: ";
    std::cin >> idade;
    std::cout << nome << " tem " << idade << " anos.\n";
}

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 | (aula Entrada com cin), 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 Funções e, em detalhe, nos projetos):

#include <iostream>

int main(int argc, char* argv[]) {
    for (int i = 0; i < argc; i++) {
        std::cout << i << ": " << argv[i] << "\n";
    }
}

$ clang++ -std=c++23 -Wall -Wextra programa.cpp -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 .cpp são compilados juntos num programa só (aula Compilar Vários Arquivos);
• os outros (.h, .txt, .csv) ficam na pasta em que o programa roda, /home/ana, e o programa pode abri-los;
• arquivos que o programa cria (com std::ofstream) vivem numa pasta na memória, que começa limpa a cada Rodar.

#include <fstream>
#include <iostream>
#include <string>

int main() {
    std::ifstream arquivo("lista.txt");
    std::string item;
    int n = 0;
    while (std::getline(arquivo, item)) {
        n = n + 1;
        std::cout << n << ". " << item << "\n";
    }
}

arroz
feijão
café

O programa abre o lista.txt da outra aba e numera as linhas (a aula Ler e Escrever 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 .cpp sem a extensão.

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 std::println") ou um erro de propósito, para você ver a mensagem. Como esta:

#include <iostream>

int main() {
    std::cout << "Vou dar erro de propósito\n";
}

#include <iostream>

int main() {
    std::cout << "Vou dar erro de propósito\n"
}

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 × g++ no terminal

As caixas usam o Clang; os terminais das aulas mostram o g++. Os dois seguem o mesmo padrão C++23, 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 ;

$ g++ -std=c++23 -Wall -Wextra erro.cpp -o erro
erro.cpp: In function ‘int main()’:
erro.cpp:4:33: error: expected ‘;’ before ‘}’ token
    4 |     std::cout << "Olá, mundo!\n"
      |                                 ^
      |                                 ;
    5 | }
      | ~
$ clang++ -std=c++23 -Wall -Wextra erro.cpp -o erro
erro.cpp:4:34: error: expected ';' after expression
    4 |     std::cout << "Olá, mundo!\n"
      |                                 ^
      |                                 ;
1 error generated.

O g++ 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 g++ começa dizendo em que função está (In function ‘int main()’);
• o g++ usa aspas curvas (‘;’), o Clang aspas retas (';');
• a coluna: 33 no g++ e 34 no Clang. O Clang conta bytes, e o á de "Olá" ocupa dois bytes em UTF-8; o g++ conta caracteres. Numa linha sem acentos, os dois dão o mesmo número.

2. Um nome que não existe

$ g++ -std=c++23 -Wall -Wextra total.cpp -o total
total.cpp: In function ‘int main()’:
total.cpp:5:39: error: ‘quantidade’ was not declared in this scope
    5 |     std::cout << "Total: " << preco * quantidade << "\n";
      |                                       ^~~~~~~~~~
$ clang++ -std=c++23 -Wall -Wextra total.cpp -o total
total.cpp:5:39: error: use of undeclared identifier 'quantidade'
    5 |     std::cout << "Total: " << preco * quantidade << "\n";
      |                                       ^~~~~~~~~~
1 error generated.

g++: "quantidade não foi declarada neste escopo". 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. Aspas sem fechar: 391 linhas × 5

$ g++ -std=c++23 -Wall -Wextra aspas.cpp -o aspas 2>&1 | wc -l
391                                                « o g++ se perde e escreve 391 linhas
$ clang++ -std=c++23 -Wall -Wextra aspas.cpp -o aspas
aspas.cpp:4:18: warning: missing terminating '"' character [-Winvalid-pp-token]
    4 |     std::cout << "Olá, mundo!\n;
      |                  ^
aspas.cpp:4:18: error: expected expression
1 warning and 1 error generated.

Aqui a diferença é grande: depois de dizer missing terminating " character nas primeiras linhas, o g++ tenta entender o resto e despeja centenas de linhas de consequências (a aula Editores e IDEs mostra o começo). O Clang para logo. Nos dois, a lição é a mesma: a primeira mensagem é a que importa.

4. Erro do ligador

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

$ clang++ -std=c++23 -Wall -Wextra programa.cpp -o programa
wasm-ld: error: /tmp/programa-62bf3f.o: undefined symbol: soma(int, int)
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 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"); 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 C++23 que o guia ensina: std::cout, std::print/std::println, std::format, std::string, std::vector e os outros contêineres, ranges, lambdas, classes, templates, concepts, ponteiros inteligentes.
• Exceções (try, catch, throw).
• Entrada (std::cin, std::getline), argumentos, arquivos das abas e arquivos criados pelo programa.
• Números aleatórios, <chrono>, std::this_thread::sleep_for.
• Outras versões do C++, quando a caixa pede (aula Versões do C++ tem uma caixa em C++20).

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

• Threads: std::thread compila, mas, ao criar a thread, o programa termina com thread constructor failed: Not supported. A aula Threads usa o terminal.
• system() (rodar um comando do sistema) e rede: não há sistema nem rede dentro do navegador.
• import std;: use #include (aula Módulos).
• Depurador e sanitizers (gdb, -fsanitize): as aulas Depurar com o GDB 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.

O que é diferente no editor × no seu computador

O editor gera um programa WebAssembly de 32 bits e usa a biblioteca padrão do LLVM (a libc++). O g++ do Linux gera um programa x86-64 de 64 bits e usa a biblioteca do GCC (a libstdc++). 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 g++ 15 da Ana.

A lição mais importante está nas linhas do v[10] e do delete duplo: um erro que "passa em silêncio" continua sendo um erro. Em C++, acessar fora do vetor 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 g++ fizeram coisas diferentes justamente por isso. A aula Comportamento Indefinido trata do assunto, e as aulas Sanitizers e Depurar com o GDB 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 <iostream>

int main() {
    std::cout << "int: " << sizeof(int) << "\n";
    std::cout << "long: " << sizeof(long) << "\n";
    std::cout << "long long: " << sizeof(long long) << "\n";
    std::cout << "ponteiro: " << sizeof(int*) << "\n";
}

Por isso o guia prefere int e long long, que têm o mesmo tamanho nos dois, e explica os tamanhos na aula Inteiros.

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

$ ./nulo
Falha de segmentação     (imagem do núcleo gravada) ./nulo
$ ./divzero
antes
Exceção de ponto flutuante (imagem do núcleo gravada) ./divzero
$ ./excecao
antes
terminate called after throwing an instance of 'std::runtime_error'
  what():  deu ruim
Abortado                   (imagem do núcleo gravada) ./excecao
$ ./doublefree
free(): double free detected in tcache 2
Abortado                   (imagem do núcleo gravada) ./doublefree

Quando dá errado

Referência

Exercícios

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

#include <iostream>

int main() {
    std::cout << "Tudo certo.\n";
    return 0;
}

#include <iostream>

int main() {
    std::cout << "Arquivo não encontrado.\n";
    return 3;
}

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

$ ./saida
Algo deu errado.
$ echo $?
3

Resumo

• As caixas Experimente compilam C++ de verdade com o Clang 22 em WebAssembly, no navegador, com -std=c++23 -Wall -Wextra, e rodam o programa.
• Na primeira vez, o navegador baixa uns 33 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].
• std::cin: 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 g++ dizem a mesma coisa com palavras diferentes: use of undeclared identifier × was not declared in this scope. Leia sempre a primeira mensagem.
• Diferenças: long e ponteiros têm 4 bytes no editor e 8 no Linux; threads, system(), gdb 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.