Introdução ao comando de repetição `while`

Nas seções sobre variáveis e sobre comando de seleção, pudemos perceber os conceitos básicos da computação que nos permite construir sistemas sofisticados. Com variáveis é possível armazenar e trocar valores e com a seleção (if) pode-se desviar o fluxo de execução de acordo com valores que as variáveis assumem.

Entretanto, falta um conceito essencial para permitir computação significativa, que é a repetição condicionada de comandos. Quer dizer, é possível repetir um bloco de comandos enquanto uma condição é verdadeira. Depois examinaremos outras formas, como repetir até determinanda condição se verificar ou repetir um número de vezes. com os dois conceitos

A figura 1 ilustra o fluxo de execução de um comando do tipo repita enquanto:

1. testa a condição lógica,
2. se resultar verdadeiro, então entra no laço, ou seja, segue o caminho indicado pela seta com rótulo sim;

1. executa todos os comandos subordinados ao laço, o bloco de repetição;
2. volta ao passo 1, ao início do laço (por isso este é classificado como laço com condição de entrada);

3. se resultar falso, então sai no laço, ou seja, segue o caminho indicado pela seta com rótulo não;

Fig. 1. Diagrama de fluxo de execução (a) sem o ramo de senão e (b) com o ramo de senão ..

A estrutura básica do comando de repetição com condição de entrada é formado por 3 partes, uma marca indicando o comando (`while`), seguido de uma expressão lógica (EXPL) depois o bloco de comandos subordinados. Assim, se tiver apenas um comando subordinado a sintaxe C e Python são:

C | Python
--- | ---

    <azul>while</azul> (EXPL) // em C e' obrigatorio os '(' e ')'
       comando1;

    <azul>while</azul> (EXPL): <cyan># note que em Python '(' e ')' sao opcionais</cyan>
       comando1

O significado (semântica) do código acima, durante sua execução, é:

1. | Verifica-se a condição `EXPL`, se o seu resultado for verdadeiro executa-se o passo 2, senao vai para passo 3 (final do comando)
2. | Executa-se o comando "comando1", depois volta-se a executar o passo 1.
3. | Final do bloco de repetição!

Vários comandos subordinados ao mesmo comando de repetição `while`

Se houver necessidade de vários comandos subordinados ao comando de repetição, então em C deve-se usar as marcas '{' e '}' para anotar o início e o fim do bloco. Em Python não é necessário devido à indentação ser obrigatória e por ser capaz de identificar todos os comandos subordinados. Assim, vejamos um trecho de código que gerar e imprimir os naturais entre 1 e N:

C | Python
--- | ---

    <verd>scanf</verd>("%d", &N); <cyan>// ler valor limite N</cyan>
    i = 0; <cyan>// variavel para "contar"</cyan>
    <azul>while</azul> (i < N) {
       i = i+1; <cyan>// leia-se como: i recebe o valor de i acrescido de 1</cyan>
       <verd>print</verd>f("i=%d\n", i);
       } <cyan>// final do bloco</cyan>
    <verd>print</verd>f("Final!");

    N = <verm>int</verm>(<verd>input</verd>()); <cyan># ler valor limite N</cyan>
    i = 0 <cyan># variavel para "contar"</cyan>
    <azul>while</azul> (i < N) :
       i = i+1 <cyan># a indentacao indica esta linha</cyan>
       <verd>print</verd>("i=", i) <cyan># e a proxima linha como sobordinadas 'a repeticao</cyan>
       <cyan># para indicar final do bloco basta a proxima linha estar alinhada com o "while"</cyan>
    <verd>print</verd>("Final!")

Exercitando a compreenção: simulando o código

É interessante usar simulações para melhor compreender o desenvolvimento dos algoritmos, mais ainda se você detectar algum erro em seu código, que portanto precisa ser corrigido. Adotaremos o seguinte esquema de simulação: usaremos uma tabela com as variáveis do código e registraremos cada alteração em uma linha, seguindo o fluxo de execução de cima para baixo, de modo que o último valor de uma variável (em qualquer ponto/linha) será o primeiro valor, na coluna da variável, encontrado "olhando" para "cima". Indicaremos as atribuições com ":=".

                                                        N | i     impressoes
                                                       ---+---    ----------
    * leitura para inteiro N                            3 | ?
    i := 0                                                | 0
    * entra no laco "while" pois 0=i<N=3                  |
    i := 1 (pois: i recebe i+1=0+1)                       | 1
    * saida: i=1                                          |       i=1
    * final do laco "while" volta para condicao           |
    * entra no laco "while" pois 1=i<N=3                  |
    i := 2 (pois: i recebe i+1=1+1)                       | 2
    * saida: i=2                                          |       i=2
    * final do laco "while" volta para condicao           |
    * entra no laco "while" pois 2=i<N=3                  |
    i := 3 (pois: i recebe i+1=2+1)                       | 3
    * saida: i=3                                          |       i=3
    * final do laco "while" volta para condicao           |
    * sai no laco "while" pois 3=i<N=3 = falso!!!         |       Final!

Para estudar um pouco mais:

1. em C siga este apontador;
2. em Python siga este apontador.

Leônidas de Oliveira Brandão
http://line.ime.usp.br

Alterações:
2020/08/20: acertos formato
2020/08/11: imagem diagrama de fluxo (e texto), novo formato, pequenas revisões
2019/03/31: verao 1.1
2017/04/14: verao 1.0