Estruturas de repetição

As estruturas de repetição em C++, também conhecidas como repetições ou loops, são fundamentais para executar um bloco de instruções várias vezes, de acordo com uma condição estabelecida. Elas permitem automatizar tarefas repetitivas, percorrer listas e processar dados em série, tornando o código mais eficiente e compacto.

Em C++, existem três estruturas principais de repetição:

1. Repetição for

A repetição for é indicado quando se conhece o número exato de repetições.

Sintaxe:

for (inicialização; condição; atualização) {
    // comandos a serem repetidos
}

• Inicialização: executada uma vez, antes da repetição começar.
• Condição: avaliada antes de cada iteração; se for verdadeira, executa o bloco.
• Atualização: executada ao final de cada iteração.

Exemplo: Imprimir números de 1 a 10

#include <iostream>
using namespace std;

int main() {
    for(int i = 1; i <= 10; i++) {
        cout << i << endl;
    }
    return 0;
}

2. Repetição while

O laço while é usado quando não se sabe exatamente quantas vezes o bloco será executado, pois depende de uma condição dinâmica. Ele testa a condição antes de cada iteração.

Sintaxe:

while (condição) {
    // comandos a serem repetidos
}

Exemplo: Imprimir números de 1 a 10

#include <iostream>
using namespace std;

int main() {
    int count = 1;
    while(count <= 10) {
        cout << count << endl;
        count++;
    }
    return 0;
}

3. Repetição do-while

O laço do-while garante que o bloco de comandos seja executado pelo menos uma vez, pois a condição é testada após a execução.

Sintaxe:

do {
    // comandos a serem repetidos
} while (condição);

Exemplo: Solicitar ao utilizador um número positivo

#include <iostream>
using namespace std;

int main() {
    int num;
    do {
        cout << "Digite um número positivo: ";
        cin >> num;
    } while(num <= 0);
    cout << "Você digitou: " << num << endl;
    return 0;
}

Observações e Dicas

• Use for para repetições com número fixo de vezes.
• Use while ou do-while para repetições dependentes de condições externas ou variáveis.

Cláusulas break e continue

As cláusulas break e continue em C++ são instruções de controle de fluxo utilizadas dentro de estruturas de repetição. Elas permitem alterar o comportamento padrão dos loops, tornando o código mais flexível e eficiente.

break

A instrução break serve para interromper imediatamente a execução de um loop (for, while, do-while) ou de um bloco switch, transferindo o controle para a próxima linha após o bloco encerrado. Quando o break é executado, a repetição é finalizada, mesmo que a condição de repetição ainda seja verdadeira.

Exemplo com for:

for (int i = 0; i < 10; i++) {
    if (i == 4) {
        break;
    }
    cout << i << endl;
}

Neste exemplo, a contagem será interrompida quando i atingir 4, e o loop será encerrado.

Exemplo com while:

int i = 0;
while (i < 10) {
    cout << i << endl;
    i++;
    if (i == 4) {
        break;
    }
}

Aqui, o loop também termina quando i chega a 4.

O break também pode ser utilizado em loops aninhados, encerrando apenas o loop mais interno onde está inserido5.

continue

A instrução continue serve para saltar a execução do restante do bloco do loop na iteração atual e passar imediatamente para a próxima iteração da repetição. Ou seja, quando o continue é encontrado, o código subsequente na iteração é ignorado, e o loop prossegue normalmente.

Exemplo com for:

for (int i = 0; i < 10; i++) {
    if (i == 4) {
        continue;
    }
    cout << i << endl;
}

Neste exemplo, o número 4 não será impresso, pois quando i for igual a 4, o comando continue fará o laço saltar para a próxima iteração, ignorando o cout.

Exemplo com while:

int i = 0;
while (i < 10) {
    if (i == 4) {
        i++;
        continue;
    }
    cout << i << endl;
    i++;
}

Aqui, o número 4 também será ignorado na saída.

Quando usar break e continue?

• Use break quando for necessário interromper completamente a execução de uma repetição ao atingir determinada condição.
• Use continue quando quiser apenas saltar uma iteração específica da repetição, mas continuar o restante normalmente.