Escrevendo o Seu Primeiro Programa em C++: Um Guia Visual e Prático

Todo programador começa do mesmo jeito: fazendo o computador dizer Olá, Mundo! Em C++ isso leva só cinco linhas, mas essas cinco linhas escondem bastante coisa: uma função que o sistema operacional chama, dezenas de milhares de linhas de biblioteca trazidas por um único #include e um número devolvido ao sistema quando o programa termina.

Neste guia você vai escrever, compilar e rodar o seu primeiro programa em C++ e depois desmontá-lo linha por linha. Você vai ver o que o compilador produz de verdade, aprender a ler as mensagens de erro dele (você vai ver muitas!), imprimir textos e números, ler dados do teclado e terminar com exercícios.

Todas as saídas e medições abaixo vêm de execuções reais com o GCC 14.1 (g++) no Windows. Outros compiladores imprimem mensagens um pouco diferentes, mas os programas se comportam igual. As mensagens do compilador são em inglês; vamos traduzindo as importantes.

Do que você precisa: um compilador

C++ é uma linguagem compilada. Você escreve o programa como texto (o código-fonte), e um compilador o traduz para um arquivo executável com instruções de máquina que o processador roda diretamente. Os três compiladores mais populares são o GCC (g++), o Clang (clang++) e o MSVC, da Microsoft.

Confira se funciona:

$ g++ --version
g++.exe (Rev3, Built by MSYS2 project) 14.1.0

Do código-fonte ao programa rodando

Quando você roda o g++, quatro coisas acontecem em sequência:

1. O pré-processador trata as linhas que começam com #, como o #include, colando outros arquivos no lugar delas.
2. O compilador traduz o C++ para instruções de máquina.
3. O ligador (linker) junta o seu código com a biblioteca padrão compilada num único executável.
4. Você roda o executável, e o sistema operacional o inicia chamando a main.

O menor programa em C++

Este é um programa em C++ completo e válido:

int main() {
}

• main é a função onde todo programa em C++ começa. O sistema operacional a chama quando o programa abre.
• int é o tipo de retorno dela: a main devolve um número inteiro ao sistema quando termina.
• Os parênteses () guardam os parâmetros da função; aqui não há nenhum.
• As chaves { } envolvem o corpo da função, as instruções a rodar. Ele está vazio, então o programa começa e termina na hora.

Salve como vazio.cpp, compile e rode. No macOS e no Linux:

1$ g++ vazio.cpp -o vazio
2$ ./vazio
3$ echo $?
40

O -o vazio dá nome ao arquivo de saída. No Windows, o g++ acrescenta o .exe, e você roda com vazio.exe no Prompt de Comando ou .\vazio.exe no PowerShell. Ele não imprime nada, como esperado. O echo $? mostra o número que o programa devolveu: 0. Já já falamos desse número.

Olá, Mundo!

Agora vamos fazê-lo falar. Salve isto como ola.cpp:

1#include <iostream>
2
3int main() {
4    std::cout << "Olá, Mundo!" << std::endl;
5    return 0;
6}

Compile e rode:

$ g++ ola.cpp -o ola
$ ./ola
Olá, Mundo!

Parabéns, você é um programador de C++! Agora vamos entender cada pedaço.

• #include <iostream> traz a biblioteca de fluxos de entrada e saída (input/output stream), que define o std::cout. Os sinais < > querem dizer "um cabeçalho da biblioteca padrão".
• std::cout (diga "ci-aut", de character output, saída de caracteres) representa o console. Ele mora no namespace std, a "pasta" de nomes da biblioteca padrão, daí o prefixo std::.
• << é o operador de inserção: ele empurra o que está à direita para dentro do fluxo à esquerda. As setas apontam para onde os dados vão.
• "Olá, Mundo!" é um literal de string: texto entre aspas duplas. As aspas em si não são impressas.
• std::endl termina a linha (falamos dele logo abaixo).
• ; termina cada comando, como o ponto final termina uma frase.
• return 0; termina a main e informa que deu tudo certo.

O que o #include traz de verdade

Essa única linha #include trabalha muito. Pedimos ao g++ que mostrasse a saída do pré-processador (g++ -E) para uma main vazia com cabeçalhos e padrões do C++ diferentes:

O seu Olá, Mundo é cerca de 0,02% do que o compilador lê, e quanto mais novo o padrão do C++, mais coisa o <iostream> traz junto. Não se preocupe com isso em programas pequenos, mas é por isso que projetos grandes de C++ podem levar minutos para compilar, e por isso você só inclui o que usa.

Linhas, "\n" e std::endl

Sem uma quebra de linha, a saída simplesmente para onde está. Tire o << std::endl e o prompt do terminal fica grudado no seu texto:

$ ./ola
Olá, Mundo!$

Há dois jeitos de terminar uma linha:

• "\n", o caractere de nova linha, escrito dentro de uma string. A barra invertida começa uma sequência de escape: \n é uma nova linha, \t uma tabulação, \" uma aspa dupla e \\ uma barra invertida.
• std::endl, que escreve uma nova linha e descarrega a saída (flush): ele obriga tudo o que está esperando no buffer de saída a ser escrito na hora.

Descarregar parece inofensivo, mas é lento quando acontece muito. Escrevemos um milhão de linhas num arquivo dos dois jeitos:

O mesmo arquivo, cerca de 51 vezes mais rápido com "\n". A maioria dos programadores de C++ usa "\n" por padrão, e é isso que o resto deste guia faz:

1#include <iostream>
2
3int main() {
4    std::cout << "Olá, Mundo!\n";
5    std::cout << "Tabulações:\tum\tdois\n";
6    std::cout << "Aspas: \"C++\" e uma barra invertida: \\\n";
7    return 0;
8}

Olá, Mundo!
Tabulações:	um	dois
Aspas: "C++" e uma barra invertida: \

Imprimindo mais que texto

O << pode ser encadeado, e ele imprime números e resultados de contas também:

1#include <iostream>
2
3int main() {
4    std::cout << "O C++ foi lançado em " << 1985 << ".\n";
5    std::cout << "2 + 3 = " << 2 + 3 << "\n";
6    std::cout << "7 / 2 = " << 7 / 2 << "\n";
7    std::cout << "7.0 / 2 = " << 7.0 / 2 << "\n";
8    std::cout << "Linha um\n"
9              << "Linha dois\n";
10    return 0;
11}

1O C++ foi lançado em 1985.
22 + 3 = 5
37 / 2 = 3
47.0 / 2 = 3.5
5Linha um
6Linha dois

Repare que 7 / 2 imprimiu 3: dividir dois números inteiros em C++ joga fora o resto. Faça um deles ser decimal (7.0) e você ganha 3.5 (o C++ usa ponto, não vírgula, nos números). Um comando também pode ocupar várias linhas; só o ; o termina.

return 0 e códigos de saída

O int que a main devolve é o código de saída do programa: um número que o sistema operacional guarda depois que o programa termina. Por convenção, 0 quer dizer sucesso e qualquer outro número quer dizer algum tipo de falha.

1#include <iostream>
2
3int main() {
4    std::cout << "Algo deu errado!\n";
5    return 3;
6}

1$ ./falha
2Algo deu errado!
3$ echo $?
43
5$ ./falha && echo "Isto só roda se a falha der certo"
6Algo deu errado!
7$ ./ola && echo "Isto só roda se o ola der certo"
8Olá, Mundo!
9Isto só roda se o ola der certo

Scripts, ferramentas de build e executores de testes dependem dos códigos de saída. (No PowerShell, use $LASTEXITCODE em vez de $?.) Por uma regra especial, se a main chega na chave de fechamento sem um return, ela devolve 0 automaticamente, e é por isso que o programa vazio funcionou. Escrever return 0; deixa a intenção clara.

Quando algo dá errado: erros do compilador

Você vai cometer erros de digitação, e o compilador vai pegá-los antes de o programa rodar. Aprender a ler as mensagens dele é um superpoder. Eis o primeiro engano que todo mundo comete, o ponto e vírgula esquecido:

1#include <iostream>
2
3int main() {
4    std::cout << "Olá, Mundo!" << std::endl
5    return 0;
6}

1semponto.cpp: In function 'int main()':
2semponto.cpp:4:44: error: expected ';' before 'return'
3    4 |     std::cout << "Olá, Mundo!" << std::endl
4      |                                            ^
5      |                                            ;
6    5 |     return 0;
7      |     ~~~~~~

O formato é sempre arquivo:linha:coluna: error: mensagem, seguido do código com um ^ apontando o lugar ("expected ';' before 'return'": esperava ; antes do return). O GCC até sugere o conserto.

Esqueça o #include, e o compilador não sabe o que é std::cout:

1int main() {
2    std::cout << "Olá, Mundo!" << std::endl;
3    return 0;
4}

1seminclude.cpp: In function 'int main()':
2seminclude.cpp:2:10: error: 'cout' is not a member of 'std'
3    2 |     std::cout << "Olá, Mundo!" << std::endl;
4      |          ^~~~
5seminclude.cpp:1:1: note: 'std::cout' is defined in header '<iostream>'; this is probably fixable by adding '#include <iostream>'
6  +++ |+#include <iostream>
7    1 | int main() {

("O cout não é membro do std", e a nota diz que ele está no cabeçalho <iostream>. A mensagem continua com o mesmo tipo de erro para o std::endl.) Esqueça o prefixo std:::

1#include <iostream>
2
3int main() {
4    cout << "Olá, Mundo!" << endl;
5    return 0;
6}

1semstd.cpp: In function 'int main()':
2semstd.cpp:4:5: error: 'cout' was not declared in this scope; did you mean 'std::cout'?
3    4 |     cout << "Olá, Mundo!" << endl;
4      |     ^~~~
5      |     std::cout

("O cout não foi declarado aqui; você quis dizer std::cout?") E esqueça de fechar as aspas, e o erro aponta onde a string começou:

1#include <iostream>
2
3int main() {
4    std::cout << "Olá, Mundo! << std::endl;
5    return 0;
6}

1aspas.cpp:4:18: warning: missing terminating " character
2    4 |     std::cout << "Olá, Mundo! << std::endl;
3      |                  ^
4aspas.cpp:4:18: error: missing terminating " character
5    4 |     std::cout << "Olá, Mundo! << std::endl;
6      |                  ^~~~~~~~~~~~~~~~~~~~~~~~~~
7aspas.cpp: In function 'int main()':
8aspas.cpp:5:5: error: expected primary-expression before 'return'
9    5 |     return 0;
10      |     ^~~~~~

Um erro de digitação, dois erros: o segundo é só consequência do primeiro. Sempre conserte o primeiro erro primeiro e compile de novo.

E o using namespace std;?

Muitos tutoriais escrevem using namespace std; lá no começo para poder digitar cout em vez de std::cout. Funciona, mas traz centenas de nomes da biblioteca padrão para dentro do seu programa, onde eles podem se chocar com os seus (experimente chamar uma variável de count ou distance). Em programas pequenos de estudo não faz mal; em código de verdade, e principalmente em arquivos de cabeçalho, a maioria dos guias de estilo manda escrever std::. Este guia fica com o std::.

Lendo dados do teclado

O std::cin (diga "ci-in") é o fluxo de entrada do console, e o >>, o operador de extração, tira um valor dele e guarda numa variável:

1#include <iostream>
2
3int main() {
4    int primeiro;
5    int segundo;
6    std::cout << "Primeiro número: ";
7    std::cin >> primeiro;
8    std::cout << "Segundo número: ";
9    std::cin >> segundo;
10    std::cout << primeiro << " + " << segundo << " = " << primeiro + segundo << "\n";
11    return 0;
12}

Uma execução de exemplo, em que os números depois dos dois-pontos são digitados pelo usuário:

Primeiro número: 12
Segundo número: 30
12 + 30 = 42

int primeiro; declara uma variável, uma caixa com nome que guarda um número inteiro. Para ler uma linha inteira de texto, como um nome completo, use o std::getline com uma std::string:

1#include <iostream>
2#include <string>
3
4int main() {
5    std::string nome;
6    std::cout << "Qual é o seu nome? ";
7    std::getline(std::cin, nome);
8    std::cout << "Olá, " << nome << "! Bem-vinda ao C++.\n";
9    return 0;
10}

Qual é o seu nome? Ada Lovelace
Olá, Ada Lovelace! Bem-vinda ao C++.

Opções úteis do compilador

g++ ola.cpp -o ola basta para começar, mas algumas opções (flags) deixam o compilador muito mais útil:

Os avisos (warnings) apontam código que compila mas provavelmente é um engano:

1#include <iostream>
2
3int main() {
4    int pontos = 10;
5    int naoUsada = 5;
6    std::cout << "Pontos: " << pontos << "\n";
7    return 0;
8}

1$ g++ -std=c++20 -Wall -Wextra avisos.cpp -o avisos
2avisos.cpp: In function 'int main()':
3avisos.cpp:5:9: warning: unused variable 'naoUsada' [-Wunused-variable]
4    5 |     int naoUsada = 5;
5      |         ^~~~~~~~

("Variável não usada.") Ao contrário dos erros, os avisos ainda geram um programa, mas é um bom hábito consertar todos. Um bom comando para o dia a dia é g++ -std=c++20 -Wall -Wextra ola.cpp -o ola.

Uma alternativa moderna: std::println

O C++23 trouxe o std::println, que imprime com quebra de linha e preenche os marcadores {}, num estilo emprestado do Python e do Rust:

1#include <print>
2
3int main() {
4    std::println("Olá, {}!", "Mundo");
5    std::println("{} + {} = {}", 2, 3, 2 + 3);
6}

Olá, Mundo!
2 + 3 = 5

Ele precisa de um compilador recente e de -std=c++23. Com o GCC 14 no Windows (MinGW), acrescente também -lstdc++exp no fim do comando. A maior parte do código e dos tutoriais de C++ usa o std::cout, então vale conhecer os dois.

Sua vez: pratique

Tente fazer estes antes de espiar as respostas. Compile cada um com g++ -std=c++20 -Wall -Wextra.

Exercício 1: Adivinhe a saída (aquecimento). O que exatamente isto imprime?

1#include <iostream>
2
3int main() {
4    std::cout << "Um";
5    std::cout << "Dois\n";
6    std::cout << "Três\n\nQuatro\n";
7    std::cout << 10 / 4 << " " << 10.0 / 4 << "\n";
8    return 0;
9}

Exercício 2: Conserte o programa. Ele tem três erros. Ache-os compilando e lendo as mensagens.

1#include <iostream>
2
3int main() {
4    std::cout << "Estou aprendendo C++\n"
5    cout << "É divertido!\n";
6    std::cout << "Tchau" << std:endl;
7    return 0;
8}

Exercício 3: Desenhe uma caixa. Escreva um programa que imprima exatamente isto:

+--------+
|  C++!  |
+--------+

Exercício 4: Uma calculadora pequenininha. Leia dois números inteiros e imprima a soma, a diferença, o produto e o quociente, como nesta execução de exemplo:

1Primeiro número: 17
2Segundo número: 5
317 + 5 = 22
417 - 5 = 12
517 * 5 = 85
617 / 5 = 3

Exercício 5: Conversor de temperatura (desafio). Leia uma temperatura em graus Celsius como número inteiro e imprima em Fahrenheit, usando a fórmula F = C × 9 / 5 + 32. Garanta que 37 °C dê 98.6, e não 98.

Quiz rápido

1. Em qual função todo programa em C++ começa?
2. O que o #include <iostream> traz?
3. Qual é a diferença entre "\n" e std::endl?
4. O que o return 0; no fim da main quer dizer?
5. O compilador informa 10 erros. Qual você conserta primeiro?

Respostas

Exercício 1: "Um" não tem quebra de linha, então o "Dois" continua na mesma linha. O "\n\n" faz uma linha vazia. 10 / 4 divide números inteiros, dando 2, enquanto 10.0 / 4 dá 2.5:

1#include <iostream>
2
3int main() {
4    std::cout << "Um";
5    std::cout << "Dois\n";
6    std::cout << "Três\n\nQuatro\n";
7    std::cout << 10 / 4 << " " << 10.0 / 4 << "\n";
8    return 0;
9}

1UmDois
2Três
3
4Quatro
52 2.5

Exercício 2: Falta o ponto e vírgula no fim da linha 4, falta o std:: antes do cout, e std: tem um dois-pontos só em vez de dois:

1#include <iostream>
2
3int main() {
4    std::cout << "Estou aprendendo C++\n";
5    std::cout << "É divertido!\n";
6    std::cout << "Tchau" << std::endl;
7    return 0;
8}

Estou aprendendo C++
É divertido!
Tchau

Exercício 3: Uma linha de saída por comando:

1#include <iostream>
2
3int main() {
4    std::cout << "+--------+\n";
5    std::cout << "|  C++!  |\n";
6    std::cout << "+--------+\n";
7    return 0;
8}

+--------+
|  C++!  |
+--------+

Exercício 4: Lembre que o / entre dois int joga fora o resto:

1#include <iostream>
2
3int main() {
4    int primeiro;
5    int segundo;
6    std::cout << "Primeiro número: ";
7    std::cin >> primeiro;
8    std::cout << "Segundo número: ";
9    std::cin >> segundo;
10    std::cout << primeiro << " + " << segundo << " = " << primeiro + segundo << "\n";
11    std::cout << primeiro << " - " << segundo << " = " << primeiro - segundo << "\n";
12    std::cout << primeiro << " * " << segundo << " = " << primeiro * segundo << "\n";
13    std::cout << primeiro << " / " << segundo << " = " << primeiro / segundo << "\n";
14    return 0;
15}

1Primeiro número: 17
2Segundo número: 5
317 + 5 = 22
417 - 5 = 12
517 * 5 = 85
617 / 5 = 3

Exercício 5: Escrever 9.0 em vez de 9 transforma a conta em matemática com decimais, então nada é cortado:

1#include <iostream>
2
3int main() {
4    int celsius;
5    std::cout << "Temperatura em Celsius: ";
6    std::cin >> celsius;
7    std::cout << celsius << " C = " << celsius * 9.0 / 5 + 32 << " F\n";
8    return 0;
9}

Temperatura em Celsius: 37
37 C = 98.6 F

Temperatura em Celsius: -40
-40 C = -40 F

Com celsius * 9 / 5 + 32, 37 × 9 = 333, e 333 / 5 = 66 na divisão de inteiros, dando 98 em vez de 98.6.

Quiz: (1) Na main. (2) Os fluxos de entrada e saída, incluindo o std::cout e o std::cin. (3) Os dois terminam a linha, mas o std::endl também descarrega o buffer de saída, o que deixou a escrita de um milhão de linhas cerca de 51 vezes mais lenta no nosso teste. (4) Que o programa terminou bem: 0 é o código de saída de "sucesso". (5) O primeiro: os erros seguintes muitas vezes são causados por ele.

Cola rápida

Resumindo

Cinco linhas, e agora você sabe o que cada uma faz:

• Todo programa em C++ começa na main, e o int que ela devolve é o código de saída: 0 quer dizer sucesso.
• O #include <iostream> traz a biblioteca de entrada e saída; na nossa medição, essa única linha vira cerca de 24.600 linhas (49.432 no C++23).
• std::cout << imprime textos, números e contas; std::cin >> lê dados.
• Termine as linhas com "\n"; o std::endl também descarrega a saída, o que foi cerca de 51 vezes mais lento para um milhão de linhas.
• O compilador é seu amigo: leia arquivo:linha:coluna: error, conserte o primeiro erro primeiro e ligue o -Wall -Wextra.
• Compilar é pré-processar, compilar e ligar os seus 96 bytes num executável de 119 KB.

Em seguida, aprenda a criar uma variável em C++, depois tome decisões com o comando if e repita coisas com o laço for. Para ver o quadro geral, leia O Que É a Linguagem de Programação C++?