Estruturas de Repetição

Quando escrevemos um programa, muitas vezes precisamos repetir uma mesma ação várias vezes.

Por exemplo, podemos querer mostrar várias mensagens na tela, contar passos, somar vários valores ou executar uma tarefa até que uma condição deixe de ser verdadeira.

É exatamente para isso que servem as estruturas de repetição. Elas permitem que o programa execute um bloco de código mais de uma vez, sem que a gente precise escrever o mesmo comando repetidamente.

Repetir faz parte do dia a dia

Mesmo fora da programação, fazemos repetições o tempo todo.

Pense em algumas situações:

• Enquanto ainda houver pratos sujos, você continua lavando.
• Enquanto o sinal não abre, você continua esperando.
• Para cada aluno da sala, o professor faz a chamada uma vez.
• Para contar uma contagem regressiva, você vai repetindo os números até chegar ao final.

Em todos esses casos, existe uma ideia parecida:

repetir uma ação até que alguma condição mude, ou repetir seguindo uma contagem

Na programação, fazemos isso com estruturas como enquanto e para.

O que é uma estrutura de repetição?

Uma estrutura de repetição é um comando que faz o programa voltar e executar novamente um bloco de código.

Esse bloco pode se repetir:

• enquanto uma condição for verdadeira
• uma quantidade determinada de vezes
• seguindo um contador que aumenta ou diminui

Isso é muito útil porque evita escrever o mesmo trecho várias vezes.

Veja este exemplo de ideia:

Mostrar "Bom dia" 5 vezes

Sem repetição, teríamos que escrever cinco comandos quase iguais.

Com repetição, basta dizer ao programa que ele deve executar o mesmo bloco várias vezes.

programa
{
    funcao inicio()
    {
        para (inteiro i = 1; i <= 5; i++) {
            escreva("Bom dia\n")
        }
    }
}

Estrutura enquanto

O enquanto funciona assim: o programa verifica uma condição (que pode ser verdadeiro ou falso, lembra?) e, enquanto essa condição for verdadeira, ele continua repetindo o que está dentro do escopo/bloco.

A estrutura básica é esta:

enquanto (condicao) {
    // bloco que será repetido
    // Tudo que estiver aqui dentro
    // É o escopo do enquanto
}

Vamos analisar cada parte:

• enquanto indica que haverá repetição.
• (condicao) é o que o programa vai testar antes de cada volta.
• { } delimitam o bloco que será executado várias vezes.

Exemplo simples com enquanto

Imagine um programa que mostra os números de 1 até 5.

programa
{
    funcao inicio()
    {
        inteiro contador

        contador = 1

        enquanto (contador <= 5) {
            escreva(contador, "\n")
            contador = contador + 1
        }
    }
}

Nesse exemplo:

1. o contador começa com valor 1
2. o programa verifica se contador <= 5
3. se for verdadeiro, ele mostra o valor na tela
4. depois aumenta o contador em 1
5. então volta para testar a condição novamente

Quando o contador passa a valer 6, a condição deixa de ser verdadeira. Nesse momento, a repetição termina.

flowchart TD
    A((Início)) --> B[contador = 1]
    B --> C{contador <= 5?}
    C -- Sim --> D[/IMPRIME contador/]
    D --> E[contador = contador + 1]
    E --> C
    C -- Não --> F((Fim))

Perceba um detalhe importante: dentro do enquanto, algo precisa mudar ao longo das repetições. Neste caso, quem muda é a variável contador.

Se nada mudar, a condição pode continuar verdadeira para sempre, e o programa ficará preso em uma repetição sem fim.

Quando usamos enquanto

O enquanto é útil quando ainda não sabemos exatamente quantas vezes o bloco vai repetir, mas sabemos qual condição precisa continuar verdadeira.

Por exemplo:

• enquanto a senha estiver errada, pedir novamente
• enquanto o jogador tiver vidas, continuar a partida
• enquanto o número digitado for diferente de 0, continuar lendo valores

Ou seja, o foco do enquanto está na condição.

Estrutura para

Quando queremos mais controle sobre a repetição, especialmente quando ela envolve um contador, o para é a melhor escolha.

Ele é ótimo para situações em que já sabemos por onde o contador começa, até onde ele vai e como ele deve mudar a cada repetição.

A estrutura básica é esta:

para (inteiro i = inicio; condicao; atualizacao) {
    // bloco que será repetido
}

Veja um exemplo de forma mais concreta:

para (inteiro i = 1; i <= 5; i++) {
    escreva(i, "\n")
}

Nesse comando:

• inteiro i = 1 cria o contador e define seu valor inicial
• i <= 5 diz até quando a repetição deve acontecer
• i++ aumenta o contador em 1 a cada volta

A variável i é apenas um nome muito usado para contadores. Ela poderia ter outro nome, como contador.

Contador simples: i++

Esse é o caso mais comum. O contador vai aumentando de 1 em 1.

programa
{
    funcao inicio()
    {
        para (inteiro i = 1; i <= 5; i++) {
            escreva("Volta número ", i, "\n")
        }
    }
}

Esse programa exibe:

Volta número 1
Volta número 2
Volta número 3
Volta número 4
Volta número 5

Esse tipo de repetição é útil quando queremos contar para frente.

Contador reverso: i--

Também podemos fazer o contador andar para trás.

programa
{
    funcao inicio()
    {
        para (inteiro i = 5; i >= 1; i--) {
            escreva(i, "\n")
        }
    }
}

Nesse caso:

• o contador começa em 5
• a condição é i >= 1
• i-- diminui o contador em 1 a cada repetição

Esse tipo de laço é muito útil em contagens regressivas.

Contador complexo

Nem todo contador precisa andar de 1 em 1.

Também podemos fazer mudanças diferentes, como dobrar o valor a cada repetição.

programa
{
    funcao inicio()
    {
        para (inteiro i = 1; i <= 16; i = i * 2) {
            escreva(i, "\n")
        }
    }
}

Os valores exibidos serão:

1
2
4
8
16

Perceba que o contador não está somando 1. Em vez disso, ele está sendo multiplicado por 2 a cada volta.

Esse tipo de contador pode ser útil quando os valores crescem em saltos maiores.

O contador define o comportamento do para

O mais importante no para é entender que ele junta três ideias em uma única linha:

1. onde o contador começa
2. até quando a repetição continua
3. como o contador muda a cada volta

Por isso, o para costuma ser a melhor escolha quando queremos controlar a repetição com uma contagem.

Exemplo final

Vamos comparar as duas ideias:

• enquanto foca em uma condição
• para foca em uma contagem controlada

Veja este exemplo com para para mostrar os números pares até 10:

programa
{
    funcao inicio()
    {
        para (inteiro i = 2; i <= 10; i = i + 2) {
            escreva(i, "\n")
        }
    }
}

Nesse caso, o contador começa em 2 e aumenta de 2 em 2, exibindo apenas os números pares.

Com isso, já conseguimos entender a ideia principal das estruturas de repetição e conhecer dois laços muito importantes no Portugol: enquanto e para.