7.4Estruturas de Repetição
São muito comuns as situações em que se deseja repetir um determinado trecho de um programa um certo número de vezes. Por exemplo, pode-se citar o caso de um algoritmo que calcula a soma dos números impares entre 500 e 1000 ou então um algoritmo que escreve os números maiores que 0 enquanto a sua soma não ultrapasse 1000.
As estruturas de repetição são muitas vezes chamadas de Laços ou também de Loops.
A classificação das estruturas de repetição é feito de acordo com o conhecimento prévio do número de vezes que o conjunto de comandos será executado. Assim os Laços se dividem em:
-
Laços Contados, quando se conhece previamente quantas vezes o comando composto no interior da construção será executado;
-
Laços Condicionais, quando não se conhece de antemão o número de vezes que o conjunto de comandos no interior do laço será repetido, pelo fato do mesmo estar amarrado a uma condição sujeita à modificação pelas instruções do interior do laço.
Todo algoritmo que possui um ou mais de seus passos repetidos um determinado número de vezes denomina-se algoritmo com repetição.
Com a utilização de estruturas de repetição para a elaboração de algoritmos, torna-se necessário o uso de dois tipos de variáveis para a resolução de diversos tipos de problemas: variáveis contadoras e variáveis acumuladoras.
Uma variável contadora é uma variável que recebe um valor inicial, geralmente 0 (zero) antes do início de uma estrutura de repetição, e é incrementada no interior da estrutura de um valor constante, geralmente 1, conforme o exemplo abaixo:
...
cont := 0
<estrutura_de_repetição>
...
cont := cont + 1
...
<fim_da_estrutura_de_repetição>
...
Uma variável acumuladora é uma variável que recebe um valor inicial, geralmente 0 (zero) antes do início de uma estrutura de repetição, e é incrementada no interior da estrutura de um valor variável, geralmente a variável usada na estrutura de controle, conforme o exemplo abaixo:
...
soma := 0
<estrutura_de_repetição_com_variável_x>
...
soma := soma + x
...
<fim_da_estrutura_de_repetição>
...
7.4.1Laços Contados ( Para ... faça )
Os laços contados são úteis quando se conhece previamente o número exato de vezes que se deseja executar um determinado conjunto de comandos. Então, este tipo de laço nada mais é que uma estrutura dotada de mecanismos para contar o número de vezes que o corpo do laço (ou seja, o comando composto em seu interior) é executado.
Há duas sintaxes possíveis usadas em algoritmos para os laços contados:
-
PARA <variável> DE <início> ATÉ <final> FAÇA <comando_único>
Ex.: Para i De 1 Até 10 Faça Escrever i, “ x 7 = ”, i * 7
-
PARA <variável> DE <início> ATÉ <final> FAÇA
INÍCIO
<comando_composto>
FIM
Ex.: soma := 0
Para i De 1 Até 10 Faça
Início
soma := soma + i
Escrever i, “ x 7 = ”, i * 7
Escrever “Soma acumulada = ”, soma
Fim
A semântica do laço contado é a seguinte: no início da execução da construção o valor início é atribuído à variável var. A seguir, o valor da variável var é comparado com o valor final. Se var for maior que final, então o comando composto não é executado e a execução do algoritmo prossegue pelo primeiro comando seguinte ao comando_único ou à palavra-reservada fim que delimita o final da construção. Por outro lado, se o valor de var for menor ou igual a final, então o comando composto no interior da construção é executado e, ao final do mesmo a variável var é incrementada em 1 unidade. Feito isso, retorna-se à comparação entre var e final e repete-se o processo até que var tenha um valor maior que final, quando o laço é finalizado e a execução do algoritmo prossegue pela instrução imediatamente seguinte à construção.
Existe uma condição especial em que a contagem deve ser de forma decrescente, onde o valor a variável é decrementado em uma unidade. A sintaxe deste laço é a seguinte:
PARA <variável> DE <início> ATÉ <final> PASSO -1 FAÇA
INÍCIO
<comando_composto>
FIM
Exemplo de um algoritmo que escreve a tabuada de um número específico:
Algoritmo tabuada
Var i, tab, num : inteiro
Início
Escrever “Tabuada: ”
Ler tab
Escrever “Até que número: ”
Ler num
Para i de 1 Até num Faça
Início
Escrever i, “ x ”, tab, “ = ”, i * tab
Fim
Fim.
7.4.2Laços Condicionais
Laços condicionais são aqueles cujo conjunto de comandos em seu interior é executado até que uma determinada condição seja satisfeita. Ao contrário do que acontece nos laços contados, nos laços condicionais não se sabe de antemão quantas vezes o corpo do laço será executado.
As construções que implementam laços condicionais mais comuns nas linguagens de programação modernas são:
-
Enquanto - laço condicional com teste no início
-
Repita - laço condicional com teste no final
Nos laços condicionais a variável que é testada, tanto no início quanto no final do laço, dever sempre estar associada a um comando que a atualize no interior do laço. Caso isso não ocorra, o programa ficará repetindo indefinidamente este laço, gerando uma situação conhecida como “laço infinito”.
7.4.2.1Laços Condicionais com Teste no Início ( Enquanto ... faça )
Caracteriza-se por uma estrutura que efetua um teste lógico no início de um laço, verificando se é permitido ou não executar o conjunto de comandos no interior do laço.
A sintaxe é mostrada a seguir:
ENQUANTO <condição> FAÇA
INÍCIO
<comando_composto>
FIM
Sua semântica é a seguinte: ao início da construção Enquanto a condição é testada. Se seu resultado for falso, então o comando composto no seu interior não é executado e a execução prossegue normalmente pela instrução seguinte à palavra-reservada fim que identifica o final da construção.
Se a condição for verdadeira o comando composto é executado e ao seu término retorna-se ao teste da condição. Assim, o processo acima será repetido enquanto a condição testada for verdadeira. Quando esta for falsa, o fluxo de execução prossegue normalmente pela instrução seguinte à palavra-reservada fim que identifica o final da construção.
Uma vez dentro do corpo do laço, a execução somente abandonará o mesmo quando a condição for falsa. O usuário deste tipo de construção deve estar atento à necessidade de que em algum momento a condição deverá ser avaliada como falsa. Caso contrário, o programa permanecerá indefinidamente no interior do laço (laço infinito).
Neste tipo de laço condicional a variável a ser testada deve possuir um valor associado antes da construção do laço.
O algoritmo que escreve os números maiores que 0 enquanto a sua soma não ultrapasse 1000 é um exemplo deste tipo de laço:
Algoritmo exemplo_enquanto
Var soma, num : inteiro
Início
soma := 0
num := 1
Enquanto soma < 1000 Faça
Início
Escreva num
num := num + 1
soma := soma + num
Fim
Fim.
7.4.2.2Laços Condicionais com Teste no Final ( Repita ... até que )
Caracteriza-se por uma estrutura que efetua um teste lógico no final de um laço, verificando se é permitido ou não executar novamente o conjunto de comandos no interior do mesmo.
A sintaxe é mostrada a seguir:
REPITA
<comando_composto>
ATÉ QUE <condição>
Seu funcionamento é bastante parecido ao da construção Enquanto. O comando é executado uma vez. A seguir, a condição é testada: se ela for falsa, o comando composto é executado novamente e este processo é repetido até que a condição seja verdadeira, quando então a execução prossegue pelo comando imediatamente seguinte ao final da construção.
Esta construção difere da construção Enquanto pelo fato de o comando composto ser executado uma ou mais vezes (pelo menos uma vez), ao passo que na construção Enquanto o comando composto é executado zero ou mais vezes (possivelmente nenhuma). Isto acontece porque na construção Repita o teste é feito no final da construção, ao contrário do que acontece na construção Enquanto, onde o teste da condição é efetuado no início da mesma.
A construção Repita também difere da construção Enquanto no que se refere à inicialização da variável, visto que na construção Repita a variável pode ser inicializada ou lida dentro do laço.
O algoritmo que lê um número não determinado de vezes um valor do teclado e escreve o valor e o seu quadrado, até que seja digitado um valor par, é um exemplo desta estrutura:
Algoritmo exemplo_repita
Var num : inteiro
Início
Repita
Ler num
Escrever num, “ - ”, num * num
Até que num mod 2 = 0
Fim.
|