Seu primeiro programa

C++ / Fundamentos

por Marlowe Prescott

Iniciante

Entenda o conceito

Todo programa em C++ começa pela função main. Quando você roda o executável, o sistema chama main, que executa suas instruções de cima para baixo e devolve um número inteiro: 0 significa que tudo deu certo.

Para escrever no terminal, usamos std::cout, a saída padrão, declarada no cabeçalho <iostream>. O operador << envia valores para ela e pode ser encadeado: std::cout << "Total: " << 42 << '\n'; imprime texto, número e quebra de linha numa só instrução.

C++ é uma linguagem compilada: o arquivo .cpp passa pelo compilador (por exemplo, g++ -std=c++20 ola.cpp -o ola), que gera um executável. Erros de digitação, como esquecer um ;, aparecem já na compilação, antes de o programa rodar.

Para saídas mais caprichadas, o cabeçalho <iomanip> oferece manipuladores como std::setw (largura da coluna) e std::setprecision (casas decimais), úteis para montar tabelas e comprovantes alinhados.

↳ Pontos-chave

Todo programa tem uma função int main(); ela é o ponto de partida e return 0; indica sucesso.
#include <iostream> traz o std::cout, e o prefixo std:: indica que ele vem da biblioteca padrão.
O operador << pode ser encadeado para imprimir textos, números e expressões na mesma instrução.
Use '\n' para quebrar a linha; std::endl também quebra, mas ainda força a escrita imediata do buffer.
Toda instrução termina com ;; esquecer esse sinal é o erro de compilação mais comum de quem começa.

Do conceito à prática

3 exemplos para ver a ideia funcionando.

01Olá, loja virtual

ola.cpp

// Primeiro programa: mostra uma saudação no terminal
#include <iostream>  // traz std::cout para escrever na tela

// Todo programa C++ começa pela função main
int main() {
    // std::cout é a saída padrão; << envia o texto para ela
    std::cout << "Olá, loja virtual!\n";

    // Cada instrução termina com ponto e vírgula
    std::cout << "Bem-vindo ao seu primeiro programa em C++.\n";

    // "\n" quebra a linha; sem ele, o texto seguinte cola no anterior
    std::cout << "Hoje temos ";
    std::cout << "frete grátis!\n";

    // Retornar 0 avisa ao sistema que tudo deu certo
    return 0;
}

O menor programa útil em C++: inclui <iostream>, define main e usa std::cout para escrever no terminal. Cada instrução termina com ; e cada frase termina com \n para pular de linha.

As duas últimas chamadas mostram que std::cout não quebra a linha sozinho: "Hoje temos " e "frete grátis!" saem na mesma linha porque só o segundo texto tem \n.

02Etiqueta de produto com textos e números

etiqueta.cpp

// Etiqueta de produto: encadeando textos e números com <<
#include <iostream>

int main() {
    // O operador << pode ser encadeado na mesma instrução
    std::cout << "Produto: " << "Caneca de cerâmica" << '\n';

    // Números inteiros e decimais são impressos sem aspas
    std::cout << "Quantidade em estoque: " << 42 << '\n';
    std::cout << "Preço unitário: R$ " << 29.9 << '\n';

    // Expressões são calculadas antes de serem impressas
    std::cout << "Valor de 3 unidades: R$ " << 3 * 29.9 << '\n';

    // Parênteses deixam claro o que é cálculo
    std::cout << "Restam após a venda: " << (42 - 3) << '\n';

    // std::endl também quebra a linha e ainda esvazia o buffer
    std::cout << "Fim da etiqueta" << std::endl;

    return 0;
}

Aqui o operador << aparece encadeado: numa só instrução vão o rótulo, o valor e a quebra de linha. Números inteiros e decimais são escritos sem aspas, e expressões como 3 * 29.9 são calculadas antes de chegar à tela.

A última linha usa std::endl, que quebra a linha e força a escrita imediata. No dia a dia, '\n' basta e é mais rápido; std::endl vale quando você precisa garantir que o texto apareceu antes de seguir.

03Comprovante de compra alinhado

comprovante.cpp

// Comprovante de compra alinhado com <iomanip>
#include <iomanip>   // std::setw, std::setfill, std::fixed, std::setprecision
#include <iostream>

int main() {
    // Linha de 30 traços: setfill troca o caractere de preenchimento
    std::cout << std::setfill('-') << std::setw(30) << "" << '\n';
    std::cout << std::setfill(' ');

    std::cout << "   COMPROVANTE DE COMPRA\n";

    // Duas casas decimais para todos os valores em reais
    std::cout << std::fixed << std::setprecision(2);

    // std::left alinha o nome à esquerda numa coluna de 20
    // std::right alinha o preço à direita numa coluna de 10
    std::cout << std::left << std::setw(20) << "Caderno"
              << std::right << std::setw(10) << 18.5 << '\n';
    std::cout << std::left << std::setw(20) << "Caneta azul"
              << std::right << std::setw(10) << 3.0 << '\n';
    std::cout << std::left << std::setw(20) << "Mochila"
              << std::right << std::setw(10) << 129.9 << '\n';

    std::cout << std::setfill('-') << std::setw(30) << "" << '\n';
    std::cout << std::setfill(' ');

    // O total é calculado na própria linha de saída
    std::cout << std::left << std::setw(20) << "Total"
              << std::right << std::setw(10) << 18.5 + 3.0 + 129.9 << '\n';

    // Mensagens de erro ou aviso vão para std::cerr, não para std::cout
    std::cerr << "(aviso: comprovante sem valor fiscal)\n";

    return 0;
}

Com <iomanip>, a saída vira uma tabela: std::setw define a largura do próximo valor, std::left e std::right escolhem o alinhamento e std::fixed com std::setprecision(2) mostra sempre duas casas decimais. O separador é um texto vazio com largura 30 preenchida por -.

O aviso final vai para std::cerr, a saída de erros. No terminal as duas aparecem juntas, mas quem redireciona a saída para um arquivo (./comprovante > nota.txt) recebe só o comprovante, sem o aviso.

Agora é com você

Tente resolver no rascunho antes de abrir a resposta. Os códigos não são executados nesta página.

01Cartão da bibliotecaFácil

Escreva um programa que mostre, em três linhas, o cartão de informações de uma biblioteca: o nome, o horário de funcionamento e o limite de empréstimos.

↳ Requisitos

Incluir <iostream> e usar std::cout para escrever no terminal.
Imprimir exatamente as três linhas da saída esperada, uma por linha, com os acentos.
Terminar cada linha com \n.
Encerrar o main com return 0;.

código inicial

#include <iostream>

int main() {
    // Escreva aqui as três linhas do cartão

    return 0;
}

saída esperada

Biblioteca Municipal
Horário: 8h às 18h
Empréstimo máximo: 3 livros

Seu rascunho (fica salvo só neste navegador)

Ver dica

Use um std::cout << "..."; para cada linha e lembre que a quebra de linha não acontece sozinha.

Ver resposta

#include <iostream>  // necessário para usar std::cout

int main() {
    // Cada linha do cartão termina com '\n'
    std::cout << "Biblioteca Municipal\n";
    std::cout << "Horário: 8h às 18h\n";
    std::cout << "Empréstimo máximo: 3 livros\n";

    return 0;  // 0 indica que o programa terminou sem erro
}

Passo a passo

#include <iostream> traz a biblioteca de entrada e saída; sem ela o compilador não conhece std::cout.
int main() é o ponto de partida: o sistema chama essa função quando o programa roda.
Cada std::cout << "..." envia um texto para a saída padrão, que normalmente é o terminal.
O \n no fim de cada texto quebra a linha, para que as três informações fiquem separadas.
Cada instrução termina com ;, que é como o C++ sabe onde ela acaba.
return 0; encerra o main e informa ao sistema que o programa terminou sem erro.

Por que funciona

Um programa C++ é uma sequência de instruções executadas de cima para baixo dentro do main. Como cada linha do cartão é uma instrução separada com \n no final, a saída sai na mesma ordem em que foi escrita, uma informação por linha.

O texto entre aspas duplas é um literal de string: o compilador o guarda exatamente como está, com acentos e espaços. Por isso basta salvar o arquivo em UTF-8 para "Horário" e "Empréstimo" aparecerem corretos no terminal.

Erros comuns

Esquecer o ;: std::cout << "Biblioteca Municipal\n" sem o ponto e vírgula gera erro de compilação ("expected ';'"). Coloque ; no fim de cada instrução.
Esquecer o std::: escrever só cout << ... dá "'cout' was not declared in this scope". O cout mora no namespace std, então use std::cout.
Esquecer o \n: sem a quebra de linha, as três frases saem grudadas numa linha só. Termine cada texto com \n.
Usar aspas simples para frases: 'Biblioteca' não é texto, é um caractere inválido com várias letras. Frases usam aspas duplas.

Outra forma de resolver

Dá para usar um único std::cout com as três linhas encadeadas: std::cout << "Biblioteca Municipal\n" << "Horário: 8h às 18h\n" << "Empréstimo máximo: 3 livros\n";. A saída é a mesma; instruções separadas costumam ser mais fáceis de ler e de alterar uma linha sem mexer nas outras.

Saída esperada

Biblioteca Municipal
Horário: 8h às 18h
Empréstimo máximo: 3 livros

02Placar de três rodadasMédio

Mostre os pontos de um jogador em três rodadas (120, 85 e 140) e, em seguida, o total e a média de pontos. O total e a média devem ser calculados pelo programa.

↳ Requisitos

Encadear texto e número com << na mesma instrução, como "Rodada 1: " << 120 << " pontos\n".
Calcular o total com uma expressão de soma dentro do std::cout, sem digitar 345.
Calcular a média com divisão inteira, usando parênteses para somar antes de dividir.
Reproduzir exatamente a saída esperada, incluindo os espaços.

código inicial

#include <iostream>

int main() {
    std::cout << "Rodada 1: " << 120 << " pontos\n";
    // Complete com as rodadas 2 e 3, o total e a média

    return 0;
}

saída esperada

Rodada 1: 120 pontos
Rodada 2: 85 pontos
Rodada 3: 140 pontos
Total: 345 pontos
Média: 115 pontos

Seu rascunho (fica salvo só neste navegador)

Ver dica

Pense na ordem das operações: a divisão é feita antes da soma, a menos que você diga o contrário.

Ver resposta

#include <iostream>

int main() {
    // Encadeia texto, número e texto na mesma instrução
    std::cout << "Rodada 1: " << 120 << " pontos\n";
    std::cout << "Rodada 2: " << 85 << " pontos\n";
    std::cout << "Rodada 3: " << 140 << " pontos\n";

    // O total é calculado pelo programa, não digitado
    std::cout << "Total: " << 120 + 85 + 140 << " pontos\n";

    // Divisão entre inteiros: o resultado também é inteiro
    std::cout << "Média: " << (120 + 85 + 140) / 3 << " pontos\n";

    return 0;
}

Passo a passo

#include <iostream> libera o uso de std::cout.
Em std::cout << "Rodada 1: " << 120 << " pontos\n"; o operador << é encadeado: primeiro sai o texto, depois o número, depois o resto da frase.
O número 120 vai sem aspas porque é um valor inteiro, não texto; o std::cout sabe convertê-lo em dígitos.
Repare no espaço dentro de " pontos\n": o << não coloca espaços sozinho, então ele precisa estar no texto.
120 + 85 + 140 é uma expressão: o C++ calcula 345 antes de imprimir, sem você digitar o resultado.
(120 + 85 + 140) / 3 usa parênteses para somar primeiro; como todos os valores são inteiros, a divisão também é inteira e dá 115.
return 0; encerra o programa com sucesso.

Por que funciona

O std::cout aceita uma corrente de valores ligados por <<, e cada valor é escrito na ordem em que aparece. Textos saem como estão, números são convertidos para dígitos e expressões são calculadas primeiro. Assim, uma única instrução monta a linha inteira do placar.

Deixar o programa calcular o total e a média evita erro de conta: se uma rodada mudar, basta trocar o número nas três expressões.

Erros comuns

Esquecer os parênteses na média: 120 + 85 + 140 / 3 divide só o 140 (a divisão tem precedência maior) e imprime 251. Escreva (120 + 85 + 140) / 3.
Colocar o número entre aspas: "120 + 85 + 140" imprime o texto da conta, e não o resultado. Expressões ficam fora das aspas.
Esquecer os espaços: "Total:" << 345 << "pontos" gera Total:345pontos. O espaço tem de estar dentro das strings.
Esperar casas decimais: 347 / 3 dá 115, não 115.67, porque inteiro dividido por inteiro descarta a parte decimal. Use 347 / 3.0 quando quiser decimais.

Outra forma de resolver

Também dá para escrever cada pedaço em uma instrução própria (std::cout << "Total: ";, depois std::cout << 345; e assim por diante). Funciona, mas o encadeamento com << deixa cada linha da saída numa linha do código, o que é mais fácil de conferir.

Saída esperada

Rodada 1: 120 pontos
Rodada 2: 85 pontos
Rodada 3: 140 pontos
Total: 345 pontos
Média: 115 pontos

03Tabela de receita em colunasDesafio

Monte no terminal a ficha de um bolo de cenoura em forma de tabela, com a quantidade de cada ingrediente para a receita normal (x1) e para a receita dobrada (x2), entre separadores de 30 sinais de igual.

↳ Requisitos

Usar std::setw, std::left e std::right de <iomanip>: nome com largura 14 à esquerda e cada quantidade com largura 8 à direita.
Gerar os separadores com std::setfill('=') e std::setw(30), sem digitar os 30 sinais.
Calcular a coluna x2 com multiplicação, sem digitar os valores dobrados.
Reproduzir exatamente a saída esperada, com as colunas alinhadas.

código inicial

#include <iomanip>
#include <iostream>

int main() {
    // Separador, título e separador

    // Cabeçalho: Ingrediente, x1, x2

    // Cenouras 3, Ovos 4, Farinha (g) 240, Leite (ml) 200

    // Separador final

    return 0;
}

saída esperada

==============================
Bolo de cenoura
==============================
Ingrediente         x1      x2
Cenouras             3       6
Ovos                 4       8
Farinha (g)        240     480
Leite (ml)         200     400
==============================

Seu rascunho (fica salvo só neste navegador)

Ver dica

Lembre-se de que setw vale só para o próximo valor, enquanto setfill e o alinhamento continuam valendo até serem trocados.

Ver resposta

#include <iomanip>   // std::setw, std::setfill, std::left, std::right
#include <iostream>

int main() {
    // Separador de 30 '=' gerado com setfill + setw
    std::cout << std::setfill('=') << std::setw(30) << "" << '\n';
    std::cout << std::setfill(' ');  // volta ao espaço

    std::cout << "Bolo de cenoura\n";

    std::cout << std::setfill('=') << std::setw(30) << "" << '\n';
    std::cout << std::setfill(' ');

    // Cabeçalho: nome em 14 colunas à esquerda, quantidades em 8 à direita
    std::cout << std::left << std::setw(14) << "Ingrediente"
              << std::right << std::setw(8) << "x1" << std::setw(8) << "x2" << '\n';

    // A coluna x2 é calculada com multiplicação
    std::cout << std::left << std::setw(14) << "Cenouras"
              << std::right << std::setw(8) << 3 << std::setw(8) << 3 * 2 << '\n';
    std::cout << std::left << std::setw(14) << "Ovos"
              << std::right << std::setw(8) << 4 << std::setw(8) << 4 * 2 << '\n';
    std::cout << std::left << std::setw(14) << "Farinha (g)"
              << std::right << std::setw(8) << 240 << std::setw(8) << 240 * 2 << '\n';
    std::cout << std::left << std::setw(14) << "Leite (ml)"
              << std::right << std::setw(8) << 200 << std::setw(8) << 200 * 2 << '\n';

    std::cout << std::setfill('=') << std::setw(30) << "" << '\n';

    return 0;
}

Passo a passo

#include <iomanip> traz os manipuladores de formatação (std::setw, std::setfill, std::left e std::right); <iostream> continua necessário para o std::cout.
std::setfill('=') << std::setw(30) << "" pede um campo de 30 colunas para um texto vazio; as 30 posições são preenchidas com =, e o separador sai sem você digitar os sinais.
std::setfill(' ') devolve o preenchimento ao espaço. O setfill é permanente: sem essa linha, as colunas da tabela seriam completadas com =.
std::setw(14) vale só para o próximo valor impresso, por isso ele aparece antes de cada coluna.
std::left faz o nome do ingrediente encostar à esquerda da coluna; std::right encosta os números à direita, alinhando as unidades como numa planilha.
std::right também é permanente, então basta escrevê-lo uma vez por linha, antes da primeira quantidade; a segunda coluna herda o alinhamento.
3 * 2, 240 * 2 e as demais expressões calculam a coluna dobrada, em vez de você digitar os resultados.
O último separador fecha a tabela e return 0; encerra o programa.

Por que funciona

O std::cout escreve valores um depois do outro, e os manipuladores de <iomanip> mudam como o próximo valor ocupa o espaço. Com largura fixa (14 + 8 + 8 = 30), cada linha tem exatamente o mesmo tamanho do separador, e as colunas ficam alinhadas qualquer que seja o número de dígitos.

Separar o que é dado (nome e quantidade) do que é formatação (largura e alinhamento) é o primeiro passo para gerar relatórios no terminal, uma das tarefas mais comuns de um programa de linha de comando.

Erros comuns

Achar que setw é permanente: std::cout << std::setw(8) << 3 << 6; alinha só o 3; o 6 sai colado. Repita std::setw antes de cada valor.
Não voltar o setfill: depois de std::setfill('='), a linha Cenouras sairia como Cenouras======.... Use std::setfill(' ') logo após o separador.
Esquecer o #include <iomanip>: o compilador acusa "'setw' is not a member of 'std'". O <iostream> sozinho não declara esses manipuladores.
Acentos dentro de setw: std::setw(14) << "Açúcar" conta bytes, e cada letra acentuada ocupa 2 bytes em UTF-8, então a coluna fica torta. Por isso os nomes da tabela não têm acento.

Outra forma de resolver

O separador também pode ser feito com std::string(30, '='), de <string>, que cria um texto com 30 sinais de igual: std::cout << std::string(30, '=') << '\n';. Essa forma não mexe no setfill, então não há o que restaurar depois; ela é preferível quando o separador aparece fora de uma tabela formatada.

Saída esperada

==============================
Bolo de cenoura
==============================
Ingrediente         x1      x2
Cenouras             3       6
Ovos                 4       8
Farinha (g)        240     480
Leite (ml)         200     400
==============================

Esta é a primeira lição da trilha de C++

Próximo na trilha de C++ →Variáveis e tipos básicos

Já estudei esta lição ⤨ Sortear outra lição Trilha completa de C++

Seu primeiro programa