Fonte: https://devschannel.com/

Editado em:

1. 4.0 Estrutura de repeticao dos algoritmos
2. Estrutura enquanto
3. do-while
4. Mesclando estruturas
5. Estrutura para
6. Estrutura para cada
7. Pare e continue
8. Material Extra

Estruturas de repetição

Elas repetem ações enquanto uma condição permanecer verdadeira. Essa condição pode ser tanto uma condição simples, como também uma condição composta, que nada mais é do que um grupo de condições. Cada ciclo do laço (loop) é chamado de iteração.

Estrutura enquanto

Um tipo de laço muito comum é o enquanto, que é o while das linguagens de programação. Veja abaixo um algoritmo onde ele está presente:

inteiro numero = 1
inteiro cuboNumero
enquanto (numero != 0) {
    escreva("Digite um número inteiro\n")
    leia(numero)
    cuboNumero = numero * numero * numero
    escreva("O cubo do número é ", cuboNumero, "\n")
}

Antes da primeira iteração, as condições do laço são avaliadas. Por isso, esse tipo de laço é chamado de repetição pré-testada. Por isso, a variável numero recebeu o valor 1. Se ela tivesse recebido o valor 0, o programa nem entraria no laço.

O laço continua sendo executado enquanto a sua condição permanecer verdadeira, ou seja, enquanto o valor da variável numero for diferente de 0. A cada iteração, todas as instruções do laço são executadas.

do-while

Um outro tipo de loop é o do-while (faça-enquanto). Nesse tipo de laço, pelo menos uma iteração ocorre, porque a avaliação da condição se dá após a execução da iteração. Por isso, esse tipo de repetição é chamada de repetição pós-testada. Veja como o algoritmo anterior poderia ser representado usando essa estrutura:

inteiro numero
inteiro cuboNumero
faca {
    escreva("Digite um número inteiro\n")
    leia(numero)
    cuboNumero = numero * numero * numero
    escreva("O cubo do número é ", cuboNumero, "\n")
} enquanto (numero != 0)

Note que aqui não é necessário atribuir um valor inicial para a variável numero que seja diferente de 0, porque a primeira iteração está garantida. Por isso, esse algoritmo ficou mais adequado a esse tipo de situação, até porque evitou a necessidade da atribuição de um valor inicial à variável usada na condição.

Mesclando estruturas

Já mostrei um exemplo onde eu aninhei estruturas de seleção. Também é possível aninhar estruturas de repetição dentro de outras estruturas de repetição ou em estruturas de seleção e vice-versa. Veja o exemplo abaixo:

inteiro numero
faca {
    escreva("Digite um número inteiro\n")
    leia(numero)
    se (numero %2 == 0) {
        escreva("O número que você digitou é par\n")
    }
    senao {
        escreva("O número que você digitou é ímpar\n")
    }
} enquanto (numero != 0)

Estrutura para

A maioria das linguagens de programação suportam o para. Ele define três ações em uma sintaxe compacta. Essas ações são inicialização, condição e atualização. A inicialização é usada para inicializar variáveis e é a primeira coisa que é feita no for. Só é feita no começo. A condição é feita antes de cada iteração, inclusive a primeira. A atualização é feita após cada iteração.

O uso mais comum de um for é inicializar uma variável, que é chamada de variável de controle, testá-la na condição do para e depois atualizá-la. Por causa do uso da variável de controle, esse tipo de repetição é chamado também de repetição com variável de controle.

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

Você também pode omitir a inicialização e a atualização:

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

Não é possível omitir a condição no Portugol Studio, embora algumas linguagens de programação, como o PHP, permitam a omissão da condição.

A atualização também pode ser chamada de step value. Seu valor pode ser positivo ou negativo. Se for positivo, é um incremento. Se for negativo, é um decremento.

É possível usar o enquanto para alcançar o mesmo efeito do para:

inteiro i = 1
enquanto (i <= 10) {
    escreva(i, "\n")
    i++
}

Veja que, pra esse tipo de situação, é muito melhor usar o para, já que é uma solução mais compacta e elegante.

Agora, eu vou inverter o exemplo, pra contar de 10 até 1. Aí, eu vou usar o decremento ao invés do incremento. Veja a diferença do mesmo exemplo feito com o para e com o enquanto:

inteiro i = 10
enquanto (i >= 1) {
    escreva(i, "\n")
    i--
}
para (i = 10; i >= 1; i--) {
    escreva(i, "\n")
}

Estrutura para cada

Uma outra estrutura de repetição é o para cada, que é o for each das linguagens de programação. Essa estrutura executa instruções para cada item de uma coleção. Então, há uma iteração para cada item. Por isso, essa estrutura é chamada de iteração de coleção. A coleção é basicamente um conjunto de dados quaisquer, não importa o tipo. Ou seja, uma coleção não é necessariamente uma array.

O para cada não é suportado pelo Portugol, mas uma maneira de representá-la em um pseudocódigo é a seguinte:

para cada (item em coleção) {
    instruções
}

Exemplo:

para cada (carro em carrosJogador) {
    instruções
}

Lembrando que, como eu falei, o Portugol não suporta essa estrutura de repetição, até porque essa estrutura não é tão universal como as outras, não é essencial como um se ou um enquanto e é mais recente. Ela é mais suportada em linguagens mais novas, como o PHP. Veja:

foreach ($carrosJogador as $carro) {
  // Instruções
}

Veja que a sintaxe do foreach do PHP é um pouco diferente. Ela especifica primeiro a coleção e depois o item dela.

O que você faz em um foreach, você também pode fazer em um for, mas se a linguagem que você usa tem um foreach, eu recomendo usá-lo, porque é uma solução mais simples, elegante e legível.

Pare e continue

Duas instruções muito comuns em linguagens de programação são o pare (que é o break das linguagens de programação) e o continue. Elas são usadas em estruturas de repetição, então eu posso usar em qualquer uma das estruturas de repetição que eu mostrei aqui. Além disso, o pare também é usado na estrutura de decisão escolha-caso.

O continue também não é suportado no Portugol. Então, vamos ver o pare, que é usado em estruturas de repetição para interrompê-las:

para (inteiro i = 10; i >= 1; i--) {
    escreva(i, "\n")
    se (i == 5) {
        pare
    }
}

O continue é usado para pular para a próxima iteração do laço. Veja abaixo um exemplo de uso dele em C++:

for (int i = 0; i < 10; i++) {

  if (i == 7) {
    continue;
  }
  // Instruções

}

Traga suas perguntas e dúvidas para o fórum e compartilhe com seus colegas ou verifique na seção perguntas e respostas se sua pergunta já não se encontra respondida lá.

O que você aprendeu:

– Estruturas de Repetição
– Repetição pré-testada
– Repetição pós-testada

Título
Texto genérico.

Se suporte ao tópico ou página