5_enquanto

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

Comandos de Repetição Enquanto e 
Faça-Enquanto 
Comandos de Repetição Enquanto 
Assim como o comando para, o comando enquanto tem como principal objetivo 
executar um bloco de comandos repetidas vezes. 
O comando de repetição enquanto possui a seguinte estrutura: 
enquanto <expressão lógica> 
{ 
 <comandos>; 
} 
Basicamente, o comando enquanto executa o bloco de comandos associado 
enquanto a expressão lógica for avaliada como verdade. 
No início da execução do comando enquanto, a expressão lógica é avaliada e, 
caso ela resulte em verdade, os comandos do bloco de comandos associado são 
executados pela primeira vez. Ao final da execução do bloco de comandos, a 
expressão lógica é avaliada novamente, e caso ela continue resultando em 
verdade, os comandos do bloco de comandos são executados novamente. O laço 
irá executar os comandos do bloco de comandos repetidamente enquanto a 
expressão lógica for avaliada como verdade. Na primeira ocasião em que a 
expressão lógica for avaliada como falso, o laço é terminado e a execução do 
programa prossegue. 
É importante ressaltar que um laço enquanto pode até mesmo não executar o 
bloco de comandos nenhuma vez. No início da execução do comando enquanto, 
quando a expressão lógica é avaliada pela primeira vez, caso ela resulte em falso 
o comando enquanto não executa o bloco de comandos. Nesse caso, o comando 
enquanto salta todos os comandos presentes no bloco de comandos associado, e 
continua a execução do programa normalmente. 
Vamos ver um algoritmo exemplo que utiliza o comando enquanto: 
01 | Algoritmo exemplo_enquanto; 
02 | 
03 | { 
04 | resp: caractere; 
05 | 
06 | 
07 | resp ´n´; 
08 | enquanto resp == ´n´ 
09 | { 
10 | escreva("Você quer parar agora <s/n>?"); 
11 | leia(resp); 
12 | } 
13 | } 
O exemplo acima utiliza uma variável chamada resp do tipo caracter. Essa 
variável irá armazenar o valor ´s´ caso o usuário queira continuar dentro do laço 
ou ´n´ caso o usuário queira parar com o laço. Repare que na linha 07 a variável 
resp é inicializada com o valor ´n´. Essa inicialização é necessária pois sem ela o 
laço não é executado nem uma única vez. Na linha 08 está o comando enquanto 
com a condição de executar o laço enquanto o valor da variável resp for igual a 
´n´. Como a variável resp foi inicializada com o valor ´n´, então os comandos 
pertencentes ao bloco de comandos associado ao comando enquanto (linhas 09, 
10, 11 e 12) são executados pela primeira vez. Dentro do laço, o comando 
escreva (linha 10) pergunta ao usuário se ele deseja parar com o laço, e o 
comando leia (linha 11) lê do teclado a resposta do usuário. O usuário deve digitar 
´s´ ou ´n´. Independentemente da resposta do usuário, a execução volta para a 
linha 08 na qual a expressão lógica do comando enquanto é avaliada novamente. 
Caso a resposta do usuário seja igual a ´n´ (ele não quer parar o laço), então o 
programa irá executar os comandos associados ao comando enquanto 
novamente. Caso o usuário tenha digitado ´s´ então o laço termina pois a 
expressão lógica 
resp == ´n´ 
é avaliada como falso, pois ´s´ não é igual a ´n´. 
Ao final da execução do laço enquanto o algoritmo irá continuar a sua execução 
normalmente. No caso do algoritmo exemplo acima, como não existem mais 
comandos após o bloco de comandos associado ao comando enquanto, a 
execução do programa termina. 
Comando de Repetição Faça-Enquanto 
O comando de repetição faça-enquanto, assim como os demais comandos de 
repetição, utiliza uma expressão lógica para controlar até quando o bloco de 
comandos deve ser executado. A estrutura do comando faça-enquanto é a 
seguinte: 
faça { 
 <comandos>; 
} enquanto <expressão lógica>; 
O comando faça-enquanto funciona da seguinte forma. Os comandos do bloco de 
comandos delimitado pelas palavras reservadas { e } são executados pela 
primeira vez. Quando a execução atinge a palavra reservada enquanto, a 
expressão lógica é avaliada pela primeira vez. Caso a expressão lógica seja 
avaliada em verdadeiro, então a execução do algoritmo volta para a palavra 
reservada {, e os comandos são executados novamente. Caso a expressão lógica 
seja avaliada como falso, então o laço termina e a execução do programa 
continua normalmente. 
Resumidamente, o laço faça-enquanto repete os comando do bloco de comandos 
associado enquanto a expressão lógica seja avaliada como verdade. 
É importante ressaltar que os comandos do bloco de comandos delimitado pelas 
palavras { e } são sempre executados pelo menos uma vez. 
Vamos ver um exemplo de algoritmo com um laço faça-enquanto: 
01 | Algoritmo exemplo_faca_enquanto; 
02 | 
03 | { 
04 | resp: caractere; 
05 | 
06 | 
08 | faça { 
10 | escreva("Você quer parar agora <s/n>?"); 
11 | leia(Resp); 
12 | } enquanto resp == ´n´; 
13 | } 
No exemplo acima, o laço faça-enquanto executa os comandos do bloco de 
comandos associado (linhas 10 e 11) enquanto a resposta digitada pelo usuário, 
armazenada na variável resp, é igual ao valor ´n´. Repare que não foi necessário 
inicializar a variável resp pois o comando leia irá ler a resposta do usuário antes 
que a condição do comando enquanto seja avaliada. 
Exercício 
1. Faça algoritmo (e um programa) que leia dois números do teclado e mais 
um operador, o qual pode ser '+', '-', '*', '/'. Por exemplo, o usuário pode 
digitar 
2. 5 
3. + 
10 
O algoritmo (programa) deve calcular o resultado da operação e imprimir na 
tela do computador. O programa deve perguntar ao usuário se ele quer 
parar, e caso ele não queira, pedir outros valores para fazer um novo 
cálculo. 
4. Faça um algoritmo (e um programa) capaz de ler uma quantidade não 
previamente determinada de valores positivos. O usuário deve indicar que 
quer parar de entrar valores digitando um valor especial, por exemplo -1. 
Calcule o total dos valores digitados pelo usuário.