Switch e Laços de Repetição em C++

Nas duas semanas passadas, você aprendeu a tomar decisões com o if, o else, decisões aninhadas, e a cadeia de else if. Mas repare numa coisa: até agora, todo programa que você escreveu executava cada comando uma única vez, e seguia direto para o próximo. Esta semana muda isso em duas frentes. Primeiro, você conhece uma ferramenta nova para tomar decisões: o switch, pensado para quando uma única variável precisa ser comparada a vários valores fixos. Depois, você aprende a repetir um bloco de comandos várias vezes, sem copiar e colar o mesmo código repetidas vezes: os laços while e do-while.

Base bibliográfica: este material segue as seções 2.2 (Estruturas de Controle, especificamente o switch) e 2.3 (Loops) de SAVITCH, C++ Absoluto (Pearson Addison Wesley, 2004).

1. A instrução switch

Quando uma cadeia de else if testa a mesma variável contra vários valores fixos, ela pode ficar longa e repetitiva: a mesma variável aparece comparada de novo e de novo, mudando só o valor do lado direito.

if (opcao == 1) { ... }
else if (opcao == 2) { ... }
else if (opcao == 3) { ... }

Para esse cenário específico, quando o teste é sempre sobre a mesma variável, C++ oferece uma estrutura dedicada, mais direta: o switch.

switch (variavel) {
    case valor1:
        comandos;
        break;
    case valor2:
        comandos;
        break;
    default:
        comandos;
}

O switch avalia o valor da variável entre parênteses e desvia a execução para o case correspondente. Um programa completo, calculando o pedágio de acordo com a classe do veículo:

#include <iostream>
using namespace std;

int main() {
    int classeVeiculo;
    double pedagio;
    cin >> classeVeiculo;

    switch (classeVeiculo) {
        case 1:
            pedagio = 0.50;
            break;
        case 2:
            pedagio = 1.50;
            break;
        case 3:
            pedagio = 2.00;
            break;
        default:
            cout << "Classe invalida" << endl;
    }
    cout << pedagio << endl;
    return 0;
}

O papel do break

O break interrompe o switch assim que um case termina de executar. Sem ele, a execução continua no case seguinte, mesmo que o valor não corresponda a ele: esse comportamento chama-se fall-through.

case 1:
    pedagio = 0.50;
    // faltou o break aqui
case 2:
    pedagio = 1.50;
    break;

Sem o break no case 1, um veículo de classe 1 sai do switch com pedagio valendo 1.50, não 0.50: a atribuição do case 2 também é executada. É um dos erros mais silenciosos de programar com switch: o programa compila e roda sem nenhum aviso, e simplesmente produz um valor errado.

A variável testada pelo switch precisa ser de um tipo inteiro (int, char, enum ). Não é possível usar double ou string diretamente na condição do switch, diferente do if, que aceita qualquer expressão relacional ou lógica.

O switch é indicado quando uma única variável é comparada a uma lista de valores fixos e discretos, como no exemplo do pedágio. A cadeia de else if, vista na Semana 3, continua sendo a escolha certa para testar faixas de valores ou condições que combinam mais de uma variável.

🎥 Vídeo 1 de 3: Switch (~5 min)

2. O laço while

Um laço de repetição executa o mesmo bloco de comandos várias vezes, enquanto uma condição se mantiver verdadeira. O while testa a condição antes de cada execução do bloco:

while (condicao) {
    comandos;
}

int x = 1;
while (x <= 5) {
    cout << x << endl;
    x++;
}

A variável x começa em 1 e é incrementada a cada repetição. O laço executa enquanto x for menor ou igual a 5, mostrando os valores 1, 2, 3, 4 e 5.

Quando o laço não executa nenhuma vez

Como o while testa a condição antes de executar o bloco, se ela já começar falsa, o bloco não executa nenhuma vez:

int x = 10;
while (x <= 5) {
    cout << x << endl;
    x++;
}

Isso não é uma falha do programa: às vezes é exatamente o comportamento esperado, como numa folha de pagamento que soma os cheques emitidos no mês, e nenhum cheque foi emitido naquele mês.

Laços infinitos

Um laço while que nunca termina é chamado de laço infinito. A causa mais comum é esquecer de atualizar a variável testada na condição:

int x = 1;
while (x <= 5) {
    cout << x << endl;
    // faltou o x++
}

Mas nem todo laço infinito vem de esquecer a atualização. Compare com este outro:

int x = 1;
while (x != 12) {
    cout << x << endl;
    x = x + 2;
}

Aqui x é atualizado a cada repetição, mas o laço nunca termina: partindo de 1, x pula de 11 direto para 13, sem nunca passar por 12. A condição x != 12 nunca vira falsa. Comparar com != é arriscado quando o valor pode pular por cima do alvo: x < 12 seria uma condição mais segura.

🎥 Vídeo 2 de 3: Laços de repetição: o while (~5 min)

3. O laço do-while, contadores e acumuladores

O do-while testa a condição depois de cada execução do bloco. Por isso, o bloco sempre executa pelo menos uma vez, mesmo que a condição já comece falsa.

do {
    comandos;
} while (condicao);

Repare no ponto e vírgula depois do while: ele é obrigatório no do-while, e não existe no while comum.

int x = 10;
do {
    cout << x << endl;
    x++;
} while (x <= 5);

Mesmo com x valendo 10 desde o início, esse trecho mostra 10 uma vez, porque o do-while executa o bloco antes de testar a condição. Com o while comum, o mesmo código não mostraria nada.

Contadores e acumuladores

Um contador é uma variável que registra quantas vezes um laço já se repetiu, geralmente incrementada de um valor fixo a cada repetição. Já apareceu nos exemplos anteriores, na variável x.

Um acumulador é uma variável que guarda o resultado de um cálculo que se constrói ao longo das repetições, e precisa começar com um valor neutro: 0 para somas, 1 para multiplicações.

int soma = 0;
int contador = 1;

while (contador <= 5) {
    int numero;
    cin >> numero;
    soma = soma + numero;
    contador++;
}

cout << soma << endl;

O contador controla quantas vezes o laço repete; o soma acumula o total lido a cada repetição. Ao final das cinco leituras, soma guarda a soma dos cinco números digitados.

🎥 Vídeo 3 de 3: Do-while, contadores e acumuladores (~5 min)

Leitura da Semana 4 - Base: Savitch, C++ Absoluto, seções 2.2 e 2.3. Faça a lista de exercícios e traga suas dúvidas para o encontro síncrono.