









Estude fácil! Tem muito documento disponível na Docsity
Ganhe pontos ajudando outros esrudantes ou compre um plano Premium
Prepare-se para as provas
Estude fácil! Tem muito documento disponível na Docsity
Prepare-se para as provas com trabalhos de outros alunos como você, aqui na Docsity
Encontra documentos específicos para os exames da tua universidade
Prepare-se com as videoaulas e exercícios resolvidos criados a partir da grade da sua Universidade
Responda perguntas de provas passadas e avalie sua preparação.
Ganhe pontos para baixar
Ganhe pontos ajudando outros esrudantes ou compre um plano Premium
- - -
Tipologia: Notas de estudo
1 / 17
Esta página não é visível na pré-visualização
Não perca as partes importantes!










Os laços são estruturas de programação em forma fechada, cuja execução geralmente é feita de modo repetitivo. A execução destes trechos de programa pode ser controlada de forma automática com comandos tais como FOR , WHILE e REPEAT (estes laços serão tratados neste texto), ou então com auxílio de instruções de desvio (não serão tratados neste texto).
Os laços formados com estrutura de repetição automática são os mais usados e pertencem a uma de duas categorias:
1 - Laços com número prefixado de iterações - escritos em PASCAL com auxílio do comando FOR e 2 - Laços com número não fixado de iterações - escritos em PASCAL com auxílio dos comandos WHILE ... DO e REPEAT ... UNTIL.
Em ambos os casos, os laços podem depender apenas de valores internos ao programa ou então ser mais abrangentes e depender de valores externos (quando utilizam variáveis cujo valor é obtido do meio exterior com auxílio de um comando de leitura).
Os laços com número prefixado de iterações são utilizados quando já se conhece com exatidão, pela natureza do problema a ser resolvido, o número de vezes que um determinado comando (ou grupo de comandos) deve ser executado.
Na linguagem PASCAL estes laços são escritos com a utilização do comando FOR.
Suponhamos, a título de ilustração, que devemos encontrar uma solução para o seguinte problema:
Escrever um programa PASCAL que leia quatro (04) valores inteiros e, para cada um dos valores imprima:
Uma possível solução seria:
PROGRAM GRANDE; VAR V1, V2, V3, V4, Q1, Q2, Q3, Q4, CB1, CB2, CB3, CB4: INTEGER; / Cada Vi representa um valor lido / / Cada Qi representa o quadrado do valor Vi / / Cada Cbi representa o cubo do valor Vi / BEGIN / PARA O PRIMEIRO VALOR... / WRITELN('INFORME UM VALOR INTEIRO'); READLN(V1); Q1 := SQR(V1); CB1 := V1 * Q1; WRITELN('VALOR 1=', 'QUADRADO=', Q1, 'CUBO=', CB1); / PARA O SEGUNDO VALOR... / WRITELN('INFORME UM VALOR INTEIRO'); READLN(V2);
PAGE 25
A solução anterior pode e deve ser melhorada de várias maneiras. Primeiro, a leitura dos quatros valores poderia ser feita de uma só vez. Segundo, como após a impressão dos valores referentes a cada número lido, os valores não mais são utilizados, não haveria necessidade de várias variáveis para armazenamento dos quadrados e dos cubos - isto poderia ser feito com apenas duas variáveis (Q e CB, respectivamente). Desta forma, o programa melhorado seria: PROGRAM MELHORADO; VAR V1, V2, V3, V4, Q, CB: INTEGER; / Cada Vi representa um valor lido / / Q representa um quadrado, em cada instante / / CB representa um cubo, em cada instante / BEGIN / PARA O PRIMEIRO VALOR... / WRITELN('INFORME QUATRO VALORES INTEIROS'); READLN(V1, V2, V3, V4); Q := SQR(V1); CB := V1 * Q; WRITELN('VALOR 1=', V1, 'QUADRADO=', Q, 'CUBO=',CB); / PARA O SEGUNDO VALOR... / Q := SQR(V2); CB := V2 * Q; WRITELN('VALOR 2=',V2,'QUADRADO='Q,'CUBO=',CB); / PARA O TERCEIRO VALOR ... / Q := SQR(V3); CB := V3 * Q; WRITELN('VALOR3=', V3, 'QUADRADO=', Q, 'CUBO=', CB); / FINALMENTE, PARA O QUARTO VALOR ... / Q := SQR(V4); CB := V4 * Q; WRITELN('VALOR 4=', V4, 'QUADRADO=', Q, 'CUBO=', CB); END.
PAGE 25
Como já afirmamos anteriormente, o comando FOR destina-se à repetição automática de um (01) comando PASCAL, enquanto que uma série de valores é atribuída à variável de controle, e aplica-se ao comando que o segue. O comando a ser executado pelo comando FOR pode ser qualquer comando simples ou composto. Um comando composto é formado por qualquer grupo de comandos delimitado por um par BEGIN ... END , podendo ser utilizado em qualquer ponto do programa onde possa vir um comando PASCAL.
A forma geral do comando FOR é:
FOR id := VrInic {TO } VrFin DO {DOWNTO} Comando;
Onde:
FOR - é uma palavra reservada em PASCAL - identifica o comando FOR ; id - é um identificador (nome de variável); VrInic - é o valor inicial que será atribuído à variável de controle (não necessariamente será 1), podendo ser de qualquer tipo escalar simples, exceto REAL; TO - é uma palavra reservada, parte integrante do comando FOR; DOWNTO - é uma palavra reservada, parte integrante do comando FOR ; VrFin - é o valor final a ser atribuído à variável de controle; Comando - é o comando a ser repetido. A variável de controle ( id ) deve ser do mesmo tipo (qualquer tipo simples, exceto REAL) que o valor inicial e que o valor final.
A opção TO indica que os valores serão atribuídos em ordem crescente à variável de controle: caso VrFin seja menor que VrInic , o comando FOR não terá nenhum efeito - o comando que o segue não será executado.
A opção DOWNTO indica que os valores serão atribuídos em ordem decrescente à variável de controle: caso VrInic seja menor que VrFin , o comando que segue o FOR não será executado.
É importante lembrar que a variável de controle não pode ter seu valor alterado dentro do domínio do comando FOR pois isso traria resultados imprevisíveis. Por outro lado, o valor da variável de controle não deve ser utilizado após a execução completa do comando FOR pois este valor dependerá do compilador que estiver sendo utilizado e pode ser indefinido em alguns casos.
Em algumas situações será interessante utilizar o valor da variável de controle para indicar o número da iteração que está sendo executada em um dado instante. Por exemplo, o segundo comando de impressão do programa PEQUENO poderia ser reescrito como:
WRITELN('VALOR', K, '=', V, 'QUADRADO=', QR(V), 'CUBO=', V * SQR(V));
Esta modificação faria com que a cada nova execução do comando acima, fosse impresso um novo valor da variável K - este valor corresponde em cada instante ao número da atual iteração visto que a variável de controle teve valor inicial igual a um (01).
OUTRO EXEMPLO
Anteriormente apresentamos um programa para cálculo da média parcial de um aluno da disciplina Introdução à Ciência da Computação. O que seria necessário fazer
PAGE 25
com o programa de modo que ele calculasse a média parcial para cinqüenta (50) alunos? A solução seria introduzir um comando FOR para repetir cinqüenta vezes o trecho de programa que calcula a média para um só aluno. Assim o novo programa seria: PROGRAM MEDIAS; VAR P1, P2, E1, E2, E3, E4, M_PARCIAL: REAL; / P1 e P2 São as provas parciais / / Cada Ei representa a nota da i-ésima lista de exercícios / K: INTEGER; M_PROVAS, M_EXERC: REAL; BEGIN FOR K := 1 TO 50 DO BEGIN WRITELN('INFORME AS NOTAS DAS DUAS PROVAS'); READLN(P1, P2); WRITELN('INFORME AS NOTAS DOS QUATRO EXERCICIOS'); READLN(E1, E2, E3, E4); M_PROVAS := (P1 + P2) / 2.0; M_EXERC := (E1 + E2 + E3 + E4) / 4.0; M_PARCIAL := M_PROVAS * 0.8 + M_EXERC * 0.2; WRITELN('PROVA1=', P1: 5: 1, 'PROVA2=', P2: 5: 1); WRITELN('EXERCICIO1=', E1: 5: 1, 'EXERCICIO2=', E2: 5: 1, 'EXERCICIO3=', E3: 5: 1, 'EXERCICIO4=', E4: 5: 1); WRITELN('MEDIA PARCIAL=', M_PARCIAL: 6: 2) END END.
Os laços com número não fixado de iterações são utilizados quando não se conhece com exatidão o número de vezes que um determinado comando (simples ou composto) deve ser executado. Nestas situações, em função do tipo de problema a ser resolvido, o número de iterações é dependente de computações internas ao programa. Em PASCAL estes laços são escritos utilizando os comandos WHILE ... DO e REPEAT ... UNTIL.
WHILE ... DO
Como exemplo inicial, consideremos o seguinte problema: Escrever um programa PASCAL que leia valores inteiros seguidamente, até encontrar um valor nulo. Para cada valor lido, exceto o último, o programa deve imprimir: o valor lido, o quadrado do valor e o seu cubo.
Utilizando o comando WHILE na solução, obtemos:
PROGRAM REPETITIVO; VAR VALOR: INTEGER; BEGIN / PARA O PRIMEIRO VALOR ... / WRITELN('INFORME UM VALOR INTEIRO');
PAGE 25
comando UNTIL condição ;
ONDE:
REPEAT - é uma palavra reservada - identifica o comando REPEAT ; comando - é o comando (ou grupo de comandos - os delimitadores BEGIN ... END são opcionais, neste caso) a ser executado; UNTIL - é uma palavra reservada de uso obrigatório; condição - é uma condição lógica que deverá possuir no mínimo uma variável e cujo valor deverá mudar dentro do comando a ser repetido - do contrário, poderá ser obtido um laço infinito. Considere o problema:
Determinar a temperatura média de João Pessoa em um certo período, sabendo- se que a última temperatura a ser informada é de 40 graus.
Como não sabemos com exatidão quantas temperaturas serão informadas, não podemos utilizar o comando FOR. Da mesma forma, como o último dos valores deve ser considerado nos cálculos então o comando WHILE não é uma boa escolha: a opção mais recomendável é utilizar o comando REPEAT. O nosso programa será:
PROGRAM TEMPERATURA; VAR TEMP: REAL; / CADA TEMPERATURA SENDO PROCESSADA / SOMA: REAL; / A SOMA DE TODAS AS TEMPERATURAS / TEMP_MED: REAL; / A TEMPERATURA MÉDIA / N_TEMP: INTEGER; / O NUMERO DE TEMPERATURAS INFORMADAS / BEGIN N_TEMP := 0; / AINDA NÃO FOI INFORMADA NENHUMA TEMPERATURA/ SOMA := 0; /* A SOMA INICIAL DAS TEMPERATURAS / REPEAT WRITELN('INFORME UMA TEMPERATURA'); READLN(TEMP); N_TEMP := N_TEMP + 1; /FOI LIDA UMA NOVA TEMPERATURA / SOMA := SOMA + TEMP; / ACUMULA A TEMPERATURA LIDA / WRITELN('TEMPERATURA LIDA=',TEMP: 5: 1); UNTIL TEMP = 40.0; TEMP_MED := SOMA / N_TEMP; /A TEMPERATURA MÉDIA / WRITELN('TEMPERATURA MEDIA', / SERÁ DETERMINADA / TEMP_MED: 6: 2) / UMA ÚNICA VEZ / END.*
Sugerimos implementar e testar o programa TEMPERATURA no computador. Que modificações seriam recomendáveis caso não se desejasse incluir a última temperatura no cálculo da temperatura média?
A implementação de decisões sobre que caminho deve ser seguido em um dado ponto de um programa PASCAL é feita com a utilização de comandos condicionais. Os comandos condicionais permitem escolher entre rotas alternativas de um trecho de
PAGE 25
programa ou então desviar um comando ou bloco de comandos, em função de alguma condição lógica cujo valor é determinado na hora da execução do programa.
Os desvios condicionais são os mais utilizados em programação. Os desvios condicionais são representados em PASCAL pelo comando IF e pelo comando CASE.
O COMANDO IF
O comando IF pode ser do tipo simples, quando tem a forma geral:
IF condição THEN comando; Onde: IF - é uma palavra reservada que identifica o comando IF ; condição - é uma condição lógica qualquer válida em PASCAL; THEN - é uma palavra reservada em PASCAL - é parte integrante do comando IF ; Comando - é um comando (simples ou composto) que deverá ser executado apenas se a condição for verdadeira;
ou do tipo composto, quando tem a forma geral:
IF condição THEN comando ELSE comando2; Onde: IF - é uma palavra reservada da linguagem PASCAL - identifica o comando IF ; condição - é uma condição lógica qualquer válida em PASCAL; THEN - é uma palavra reservada da linguagem PASCAL - é parte integrante do comando IF composto ; comando1 - é o comando a ser executado caso o valor resultante da avaliação da condição seja TRUE. Pode ser um comando simples ou composto; ELSE - é uma palavra reservada de uso obrigatório - é parte integrante do comando IF composto ; comando2 - é o comando, simples ou composto, a ser executado caso o valor resultante da avaliação da condição seja FALSE.
O programa apresentado a seguir exemplifica a utilização do comando IF :
PROGRAM SIMPLES; / DETERMINAR O MAIOR ENTRE DOIS INTEIROS / VAR A, B: INTEGER; / OS INTEIROS QUE SERÃO LIDOS E COMPARADOS / BEGIN WRITELN('INFORME DOIS VALORES INTEIROS'); READLN(A, B); WRITELN('OS VALORES LIDOS FORAM:', A: 5, 'E ', B: 5); WRITE('O MAIOR DOS DOIS VALORES'); IF A > B THEN WRITE ('EH:', A: 5)
PAGE 25
A seleção do comando a ser executado é feita comparando-se o valor da expressão_seletora com os vários rótulos do CASE.
A forma geral do comando CASE é: CASE expressão_seletora OF lista_de_rótulos_1: comando_1; lista_de_rótulos_2: comando_2; . . . lista_de_rótulos_n: comando_n END;
Onde:
CASE -- é uma palavra reservada em PASCAL - identifica o comando CASE ; expressão_seletora - é uma expressão ou variável de qualquer tipo escalar simples exceto REAL; OF - é uma palavra reservada em PASCAL - é parte integrante do comando CASE ; lista_de_rótulos_i - é uma lista contendo uma ou mais constantes de tipo compatível com o tipo da expressão_seletora , separadas por vírgula; comando_i - é um comando PASCAL qualquer (simples ou composto) que será executado caso o valor calculado para expressão_seletora seja igual a uma das constantes da lista_de_rótulos_i , podendo inclusive ser um comando vazio.
Cada rótulo que aparece em uma lista_de_rótulos deve ser de tipo compatível com o tipo da expressão_seletora e só pode aparecer em uma única lista_de_rótulos para cada comando CASE.
Só será executado algum comando das várias opções especificadas no comando CASE se o valor computado para a expressão_seletora for igual a um dos rótulos especificados. A ação a ser desenvolvida quando o valor da expressão_seletora divergir de todos os rótulos especificados nas listas_de_rótulos do comando CASE dependerá do compilador que estiver sendo utilizado: alguns compiladores dispõem da opção OTHERWISE (ou a forma equivalente ELSE ) para especificar o comando que deve ser executado quando o valor da expressão_seletora for diferente de todos os rótulos especificados nas várias listas_de_rótulos.
O programa apresentado a seguir foi escrito para uma Pousada que desejava conceder descontos progressivos aos seus clientes. Os descontos são de 10, 20, 30 e 35 por cento para os clientes que se hospedarem por 1, 2, 3 e por 4 ou mais dias, respectivamente. A entrada para o programa de computador é formada pelo valor da diária e pelo número de diárias.
Utilizando um ninho de comandos IF poderíamos ter:
PROGRAM POUSO_VELHO; CONST TFAIXA1 = 1; FAIXA2 = 2; FAIXA3 = 3; FAIXA4 = 4 .. 30;
PAGE 25
Substituindo o ninho de IFs por um comando CASE , obtemos:
PROGRAM POUSO_NOVO; CONST TFAIXA1 = 1; FAIXA2 = 2; FAIXA3 = 3; FAIXA4 = 4 .. 30; VAR VALOR_DA_DIARIA, SUB_TOTAL, SERVIÇOS: REAL; VALOR_DA_NOTA, DESCONTO, VALOR_A_PAGAR: REAL; QUANT_DIARIAS: INTEGER; BEGIN WRITELN('INFORME O VALOR DA DIARIA E A QUANTIDADE DE DIARIAS'); READLN(VALOR_DA_DIARIA, QUANT_DIARIAS); SUB_TOTAL := QUANT_DIARIAS * VALOR_DA_DIARIA; SERVIÇOS := SUB_TOTAL * 0.1 / DEZ POR CENTO / VALOR_DA_NOTA := SUB_TOTAL + SERVIÇOS; / CALCULO DO DESCONTO / CASE QUANT_DIARIAS OF FAIXA1: DESCONTO := VALOR_DA_NOTA * 0.1;
PAGE 25
PAGE 25
PAGE 25
PAGE 25
PAGE 25