Download - PImperativa08 - Modularização
Programação Imperativa Unidade 8
UFS - DComp - Prof. Kenia Kodel
Em geral, no processo de construção de
soluções computacionais algorítmicas, as
situações problemas são decompostas em
subproblemas cujas lógicas de resolução são
mais fáceis de serem compreendidas e
implementadas.
UFS - DComp - Prof. Kenia Kodel
Considerando, por exemplo, o programa de
implementação de exibição dos termos de
uma PA, foram identificados como
subproblemas: (1) próximo termo; (2) termo
anterior e (3) novo termo inicial. Houve
ainda o problema de gerenciamento da lan
house.
UFS - DComp - Prof. Kenia Kodel
UFS -
DC
om
p -
Pro
f. K
enia
Kodel
4
program SucessorAntecessor;
uses
CRT;
var
Numero: integer;
Opcao: char;
begin
writeln('Digite um numero: ');
readln(Numero);
repeat
writeln('Numero Atual: ',Numero);
writeln('1 - Sucessor');
writeln('2 - Antecessor');
writeln('3 - Outro Numero');
writeln('ESC - Sair');
write('Opcao: ');
Opcao:=readkey;
...
...
case Opcao of
'1': begin
inc(Numero);
writeln; writeln('Sucessor: ',Numero);
writeln('Pressione <ENTER>');
readln;
end;
'2': begin
dec(Numero);
writeln;
writeln('Antecessor: ',Numero);
writeln('Pressione <ENTER>');
readln;
end;
'3': begin
writeln;
writeln('Digite outro numero: ');
readln(Numero);
end;
end;
until Opcao = #27;
end.
Sub-Problemas
Tais lógicas de resolução de subproblemas
podem ser “empacotadas” em módulos. Ou seja,
os programas computacionais podem ser
decompostos em programas menores
denominados módulos, ou subprogramas.
UFS - DComp - Prof. Kenia Kodel
Em Pascal há 2 tipos de módulos.
1. Procedimentos procedure <Nome> [(parâmetro...)];
<declarações>;
begin
<comandos>;
end;
2. Funções function <Nome>[(parâmetro...)]: <tipo>;
<declarações>;
begin
<comandos>;
<Nome> := <saída>;
end;
UFS - DComp - Prof. Kenia Kodel
procedure <Nome> [(parâmetro...)];
<declarações>;
begin
<comandos>;
end;
Onde:
<Nome> é o nome do procedimento;
[(parâmetro...)] lista opcional de itens denominados argumentos, ou parâmetros; de comunicação entre programa e módulo.
<declarações>; declarações de tipos, variáveis, constantes e módulos.
<comandos>; comando ou bloco de comandos correspondentes à resoluções de um subproblema.
UFS - DComp - Prof. Kenia Kodel
program Multiplos;
uses
CRT;
const
Q = 100;
{Quantidade total de numeros}
var
Vetor: array [1..Q] of integer;
I: word;
{ocupa 2 byte, valores de 0 a 65.535}
begin
clrscr;
writeln('Digite ',Q,' numeros:');
for I:=1 to Q do
readln(Vetor[I]);
writeln('Multiplos de 2');
for I:=1 to Q do
if (Vetor[I] mod 2=0) then
writeln(Vetor[I]);
UFS - DComp - Prof. Kenia Kodel
writeln('Multiplos de 3');
for I:=1 to Q do
if (Vetor[I] mod 3=0) then
writeln(Vetor[I]);
writeln('Multiplos de 5');
for I:=1 to Q do
if (Vetor[I] mod 5=0) then
writeln(Vetor[I]);
writeln('Multiplos de 7');
for I:=1 to Q do
if (Vetor[I] mod 7=0) then
writeln(Vetor[I]);
writeln('Multiplos de 9');
for I:=1 to Q do
if (Vetor[I] mod 9=0) then
writeln(Vetor[I]);
writeln('Multiplos de 11');
for I:=1 to Q do
if (Vetor[I] mod 11=0) then
writeln(Vetor[I]);
readln;
end.
Qual o objetivo (funcionalidade) deste?
program Multiplos;
uses
CRT;
const
Q = 100;
{Quantidade total de numeros}
var
Vetor: array [1..Q] of integer;
I: word;
{ocupa 2 byte, valores de 0 a 65.535}
begin
clrscr;
writeln('Digite ',Q,' numeros:');
for I:=1 to Q do
readln(Vetor[I]);
writeln('Multiplos de 2');
for I:=1 to Q do
if (Vetor[I] mod 2=0) then
writeln(Vetor[I]);
UFS - DComp - Prof. Kenia Kodel
writeln('Multiplos de 3');
for I:=1 to Q do
if (Vetor[I] mod 3=0) then
writeln(Vetor[I]);
writeln('Multiplos de 5');
for I:=1 to Q do
if (Vetor[I] mod 5=0) then
writeln(Vetor[I]);
writeln('Multiplos de 7');
for I:=1 to Q do
if (Vetor[I] mod 7=0) then
writeln(Vetor[I]);
writeln('Multiplos de 9');
for I:=1 to Q do
if (Vetor[I] mod 9=0) then
writeln(Vetor[I]);
writeln('Multiplos de 11');
for I:=1 to Q do
if (Vetor[I] mod 11=0) then
writeln(Vetor[I]);
readln;
end.
Há subproblemas neste?
Usar procedimento para “empacotar” a solução dada aos subproblemas da questão em tela.
procedure <Nome> [(parâmetro...)];
<declarações>;
begin
<comandos>;
end;
...
writeln('Multiplos de 3');
for I:=1 to Q do
if (Vetor[I] mod 3=0) then
writeln(Vetor[I]);
writeln('Multiplos de 5');
for I:=1 to Q do
if (Vetor[I] mod 5=0) then
writeln(Vetor[I]);
...
UFS - DComp - Prof. Kenia Kodel
procedure ExibeMultiplos(N: byte);
begin
writeln('Multiplos de ',N);
for I:=1 to Q do
if (Vetor[I] mod N=0) then
writeln(Vetor[I]);
end;
program Multiplos;
uses
CRT;
const
Q = 100;
{Quantidade total de numeros}
var
Vetor: array [1..Q] of integer;
I: word;
{ocupa 2 byte, valores de 0 a 65.535}
procedure ExibeMultiplos(N: byte);
begin
writeln('Multiplos de ',N);
for I:=1 to Q do
if (Vetor[I] mod N=0) then
writeln(Vetor[I]);
end;
UFS - DComp - Prof. Kenia Kodel
begin
clrscr;
writeln('Digite ',Q,' numeros:');
for I:=1 to Q do
readln(Vetor[I]);
ExibeMultiplos(2);
ExibeMultiplos(3);
ExibeMultiplos(5);
ExibeMultiplos(7);
ExibeMultiplos(9);
ExibeMultiplos(11);
readln;
end.
Rastrear.
program Multiplos;
uses
CRT;
const
Q = 100;
{Quantidade total de numeros}
var
Vetor: array [1..Q] of integer;
I: word;
{ocupa 2 byte, valores de 0 a 65.535}
procedure ExibeMultiplos(N:
byte);
begin
writeln('Multiplos de ',N);
for I:=1 to Q do
if (Vetor[I] mod N=0) then
writeln(Vetor[I]);
end;
UFS - DComp - Prof. Kenia Kodel
begin
clrscr;
writeln('Digite ',Q,' numeros:');
for I:=1 to Q do
readln(Vetor[I]);
ExibeMultiplos(2);
ExibeMultiplos(3);
ExibeMultiplos(5);
ExibeMultiplos(7);
ExibeMultiplos(9);
ExibeMultiplos(11);
readln;
end.
A definição de um procedimento deve ser efetuada dentre as declarações do programa (principal).
program Multiplos;
uses
CRT;
const
Q = 100;
{Quantidade total de numeros}
var
Vetor: array [1..Q] of integer;
I: word;
{ocupa 2 byte, valores de 0 a 65.535}
procedure ExibeMultiplos(N: byte);
begin
writeln('Multiplos de ',N);
for I:=1 to Q do
if (Vetor[I] mod N=0) then
writeln(Vetor[I]);
end;
UFS - DComp - Prof. Kenia Kodel
begin
clrscr;
writeln('Digite ',Q,' numeros:');
for I:=1 to Q do
readln(Vetor[I]);
ExibeMultiplos(2);
ExibeMultiplos(3);
ExibeMultiplos(5);
ExibeMultiplos(7);
ExibeMultiplos(9);
ExibeMultiplos(11);
readln;
end.
Efetuada a declaração de um módulo, este pode ser “chamado” (acionado, executado) em qualquer local do programa posterior a sua definição, inclusive dentro de outro módulo; e tantas vezes quantas forem necessárias.
program Multiplos;
uses
CRT;
const
Q = 100;
{Quantidade total de numeros}
var
Vetor: array [1..Q] of integer;
I: word;
{ocupa 2 byte, valores de 0 a 65.535}
procedure ExibeMultiplos(N: byte);
begin
writeln('Multiplos de ',N);
for I:=1 to Q do
if (Vetor[I] mod N=0) then
writeln(Vetor[I]);
end;
UFS - DComp - Prof. Kenia Kodel
begin
clrscr;
writeln('Digite ',Q,' numeros:');
for I:=1 to Q do
readln(Vetor[I]);
ExibeMultiplos(2);
ExibeMultiplos(3);
ExibeMultiplos(5);
ExibeMultiplos(7);
ExibeMultiplos(9);
ExibeMultiplos(11);
readln;
end.
Um procedimento é acionado através de seu nome. Para chamar o procedimento ExibeMultiplos(N), por exemplo, basta usar dentre as instruções: ExibeMultiplos(N) substituindo N por variável ou valor do tipo byte.
Usando procedimentos, evita-se redundância de código.
program Multiplos;
uses
CRT;
const
Q = 100;
{Quantidade total de numeros}
var
Vetor: array [1..Q] of integer;
I: word;
{ocupa 2 byte, valores de 0 a 65.535}
begin
clrscr;
writeln('Digite ',Q,' numeros:');
for I:=1 to Q do
readln(Vetor[I]);
writeln('Multiplos de 2');
for I:=1 to Q do
if (Vetor[I] mod 2=0) then
writeln(Vetor[I]);
UFS - DComp - Prof. Kenia Kodel
writeln('Multiplos de 3');
for I:=1 to Q do
if (Vetor[I] mod 3=0) then
writeln(Vetor[I]);
writeln('Multiplos de 5');
for I:=1 to Q do
if (Vetor[I] mod 5=0) then
writeln(Vetor[I]);
writeln('Multiplos de 7');
for I:=1 to Q do
if (Vetor[I] mod 7=0) then
writeln(Vetor[I]);
writeln('Multiplos de 9');
for I:=1 to Q do
if (Vetor[I] mod 9=0) then
writeln(Vetor[I]);
writeln('Multiplos de 11');
for I:=1 to Q do
if (Vetor[I] mod 11=0) then
writeln(Vetor[I]);
readln;
end. Se o usuário solicitasse que
os múltiplos fossem exibidos
um ao lado do outro. Que
ajustes efetuar?
program Multiplos;
uses
CRT;
const
Q = 100;
{Quantidade total de numeros}
var
Vetor: array [1..Q] of integer;
I: word;
{ocupa 2 byte, valores de 0 a 65.535}
procedure ExibeMultiplos(N: byte);
begin
writeln('Multiplos de ',N);
for I:=1 to Q do
if (Vetor[I] mod N=0) then
writeln(Vetor[I]);
end;
UFS - DComp - Prof. Kenia Kodel
begin
clrscr;
writeln('Digite ',Q,' numeros:');
for I:=1 to Q do
readln(Vetor[I]);
ExibeMultiplos(2);
ExibeMultiplos(3);
ExibeMultiplos(5);
ExibeMultiplos(7);
ExibeMultiplos(9);
ExibeMultiplos(11);
readln;
end.
Nesta versão modularizada,
se o usuário solicitasse que
os múltiplos fossem exibidos
um ao lado do outro. Que
ajustes efetuar?
Usando procedimentos, facilita-se a manutenção de programas computacionais.
program Multiplos;
uses
CRT;
const
Q = 100;
{Quantidade total de numeros}
var
Vetor: array [1..Q] of integer;
I: word;
{ocupa 2 byte, valores de 0 a 65.535}
procedure ExibeMultiplos(N: byte);
begin
writeln('Multiplos de ',N);
for I:=1 to Q do
if (Vetor[I] mod N=0) then
writeln(Vetor[I]);
end;
UFS - DComp - Prof. Kenia Kodel
begin
clrscr;
writeln('Digite ',Q,' numeros:');
for I:=1 to Q do
readln(Vetor[I]);
ExibeMultiplos(2);
ExibeMultiplos(3);
ExibeMultiplos(5);
ExibeMultiplos(7);
ExibeMultiplos(9);
ExibeMultiplos(11);
readln;
end.
Em cada chamada a um
procedimento, o código
que o compõe é
(re)executado.
Os procedimentos, então, podem ser entendidos
como uma forma de se adicionar novos comandos
à linguagem.
Estes novos comandos aumentam
consideravelmente o poder da linguagem podendo
atender a necessidades específicas de cada
problema.
Também podem ser entendidos como uma forma
de organizar melhor os programas favorecendo a
legibilidade e manutenção destes.
UFS - DComp - Prof. Kenia Kodel
UFS -
DC
om
p -
Pro
f. K
enia
Kodel
21
program SucessorAntecessor;
uses
CRT;
var
Numero: integer;
Opcao: char;
begin
writeln('Digite um numero: ');
readln(Numero);
repeat
writeln('Numero Atual: ',Numero);
writeln('1 - Sucessor');
writeln('2 - Antecessor');
writeln('3 - Outro Numero');
writeln('ESC - Sair');
write('Opcao: ');
Opcao:=readkey;
...
...
case Opcao of
'1': begin
inc(Numero);
writeln; writeln('Sucessor: ',Numero);
writeln('Pressione <ENTER>');
readln;
end;
'2': begin
dec(Numero);
writeln;
writeln('Antecessor: ',Numero);
writeln('Pressione <ENTER>');
readln;
end;
'3': begin
writeln;
writeln('Digite outro numero: ');
readln(Numero);
end;
end;
until Opcao = #27;
end.
Retomando o problema inicial, como as sub-
rotinas podem favorecer à organização deste?
Com o uso de módulos, passamos a identificar
dois tipos de variáveis, constantes e tipos.
1. Locais – declarados dentro dos módulos
2. Globais – declarados no programa principal
Esta característica é denominada escopo.
Quando um módulo é executado, os itens locais
são criados em memória e existem somente
durante a vida (execução ) deste subprograma.
Já os globais existem durante a execução de
todo programa.
UFS - DComp - Prof. Kenia Kodel
program Multiplos;
uses
CRT;
const
Q = 100;
{Quantidade total de numeros}
var
Vetor: array [1..Q] of integer;
I: word;
{ocupa 2 byte, valores de 0 a 65.535}
procedure ExibeMultiplos(N: byte);
begin
writeln('Multiplos de ',N);
for I:=1 to Q do
if (Vetor[I] mod N=0) then
writeln(Vetor[I]);
end;
UFS - DComp - Prof. Kenia Kodel
begin
clrscr;
writeln('Digite ',Q,' numeros:');
for I:=1 to Q do
readln(Vetor[I]);
ExibeMultiplos(2);
ExibeMultiplos(3);
ExibeMultiplos(5);
ExibeMultiplos(7);
ExibeMultiplos(9);
ExibeMultiplos(11);
readln;
end.
Neste exemplo observa-
se o uso de elementos
globais somente.
program Multiplos;
uses
CRT;
const
Q = 100;
{Quantidade total de numeros}
var
Vetor: array [1..Q] of integer;
I: word;
{ocupa 2 byte, valores de 0 a 65.535}
procedure ExibeMultiplos(N: byte);
begin
writeln('Multiplos de ',N);
for I:=1 to Q do
if (Vetor[I] mod N=0) then
writeln(Vetor[I]);
end;
UFS - DComp - Prof. Kenia Kodel
begin
clrscr;
writeln('Digite ',Q,' numeros:');
for I:=1 to Q do
readln(Vetor[I]);
ExibeMultiplos(2);
ExibeMultiplos(3);
ExibeMultiplos(5);
ExibeMultiplos(7);
ExibeMultiplos(9);
ExibeMultiplos(11);
readln;
end.
Ajustar o código de
forma a exibir a
quantidade de múltiplos.
program Multiplos;
uses
CRT;
const
Q = 100;
var
Vetor: array [1..Q] of integer;
I: word;
{ocupa 2 byte, valores de 0 a 65.535}
procedure ExibeMultiplos(N: byte);
var
Contador: byte;
begin
Contador:=0;
writeln('Multiplos de ',N);
for I:=1 to Q do
if (Vetor[I] mod N=0) then
begin
writeln(Vetor[I]);
inc(Contador);
end;
writeln(‘Ha ’,Contador,’ multiplos’);
end;
UFS - DComp - Prof. Kenia Kodel
begin
clrscr;
writeln('Digite ',Q,' numeros:');
for I:=1 to Q do
readln(Vetor[I]);
ExibeMultiplos(2);
ExibeMultiplos(3);
ExibeMultiplos(5);
ExibeMultiplos(7);
ExibeMultiplos(9);
ExibeMultiplos(11);
readln;
end.
Neste caso passamos a
ter a variável local
Contador.
UFS - DComp - Prof. Kenia Kodel
Os itens locais são reconhecidos somente dentro dos módulos onde são criados. Já os globais, em todo o programa; dentro e fora dos módulos.
Como dito, opcionalmente, ao lado do nome do
procedimento, pode ser listado, entre parênteses, o
que denominamos argumentos ou parâmetros.
procedure ExibeMultiplos(N: byte);
var
Contador: byte;
begin
Contador:=0;
writeln('Multiplos de ',N);
for I:=1 to Q do
if (Vetor[I] mod N=0) then
begin
writeln(Vetor[I]);
inc(Contador);
end;
writeln(‘Ha ’,Contador,’ multiplos’);
end;
Os parâmetros são
variáveis que
servem como elo
de comunicação
entre programa e
módulos.
Os parâmetros classificam-se como:
de entrada – aqueles que fornecerão dados úteis ao processamento do módulo. Dado sua funcionalidade, não devem ser alterados pelos subprogramas.
de saída – aqueles que conterão os resultados
obtidos pelo processamento dos módulos. Assim, durante a execução do subprograma, os valores destes parâmetros devem ser definidos.
UFS - DComp - Prof. Kenia Kodel
Em Pascal é permitido que os parâmetros de saída
funcionem, também, como de entrada, ou seja,
fornecendo valores para serem usados no
processamento do módulo, bem como recebendo
os resultados obtidos. São por isto chamados
parâmetros de entrada-saída.
UFS - DComp - Prof. Kenia Kodel
Os parâmetros são definidos, entre parênteses, ao lado do nome dos módulos:
<Nome> : <tipo>;
Quando o parâmetro for de saída, deve ser precedido pela palavra reservada var.
Em Pascal, para definir parâmetros do tipo array e strings, é preciso antes definir tipo.
type
Str25 = string[25];
TpVetor = array [a..z] of byte;
...
procedure Exemplo(S: Str25; V: TpVetor);
...
UFS - DComp - Prof. Kenia Kodel
Consideremos procedimento para cálculo de raízes de equação do 2o grau.
procedure CalculaRaizes(a,b,c: real;
var r1, r2: real;
var id: char);
var
Delta: real;
begin
Delta:= b*b–4*a*c;
if Delta < 0 then id:=‘C’
else begin
id:=‘R’;
r1:=(-b+sqrt(Delta))/(2*a);
r2:=(-b-sqrt(Delta))/(2*a); end;
end;
UFS - DComp - Prof. Kenia Kodel
Quais os parâmetros de entrada e os de saída?
procedure CalculaRaizes(a,b,c: real;
var r1, r2: real;
var id: char);
var
Delta: real;
begin
Delta:= b*b–4*a*c;
if Delta < 0 then id:=‘C’
else begin
id:=‘R’;
r1:=(-b+sqrt(Delta))/(2*a);
r2:=(-b-sqrt(Delta))/(2*a); end;
end;
Neste caso temos os parâmetros a, b e c como de entrada; já que subsidiam o cálculo das raízes. E r1, r2 e id como de saída; pois armazenam os resultados do processamento.
UFS - DComp - Prof. Kenia Kodel
procedure CalculaRaizes(a,b,c: real;
var r1, r2: real;
var id: char);
var
Delta: real;
begin
Delta:= b*b–4*a*c;
if Delta < 0 then id:=‘C’
else begin
id:=‘R’;
r1:=(-b+sqrt(Delta))/(2*a);
r2:=(-b-sqrt(Delta))/(2*a); end;
end;
Uma possível chamada a este procedimento é: readln(C1,C2,C3);
CalculaRaizes(C1,C2,C3,Raiz1,Raiz2,Retorno);
if Retorno = ‘R’ then
writeln(Raiz1,Raiz2);
Com variáveis
globais, passagem
por referência.
Discutir
rastreamento
a partir da
chamada
dada abaixo.
procedure CalculaRaizes(a,b,c: real;
var r1, r2: real;
var id: char);
var
Delta: real;
begin
Delta:= b*b–4*a*c;
if Delta < 0 then id:=‘C’
else begin
id:=‘R’;
r1:=(-b+sqrt(Delta))/(2*a);
r2:=(-b-sqrt(Delta))/(2*a); end;
end;
Uma outra possível chamada a este procedimento é: CalculaRaizes(2,3,3,Raiz1,Raiz2,Retorno);
if Retorno = ‘R’ then
writeln(Raiz1,Raiz2);
Com variáveis
globais, passagem
por referência. Com constantes,
passagem por
valor.
Há duas formas de passagem de parâmetros,
possivelmente efetuadas nas chamadas a módulos:
◦ por referência – variáveis que contêm os dados
são usadas como argumentos
◦ por valor – os próprios valores são passados
como argumentos
UFS - DComp - Prof. Kenia Kodel
procedure CalculaRaizes(a,b,c: real;
var r1, r2: real;
var id: char);
var
Delta: real;
begin
Delta:= b*b–4*a*c;
if Delta < 0 then id:=‘C’
else begin
id:=‘R’;
r1:=(-b+sqrt(Delta))/(2*a);
r2:=(-b-sqrt(Delta))/(2*a); end;
end;
Por referência – variáveis que contêm os dados são usadas como argumentos.
CalculaRaizes(C1,C2,C3,Raiz1,Raiz2,Retorno); Por valor – os próprios valores são passados como
argumentos. É o caso dos 3 primeiros parâmetros. CalculaRaizes(2,3,3,Raiz1,Raiz2,Retorno);
Os parâmetros de entrada podem ser
passados por referência ou por valor; a critério do
programador; conforme situação problema.
Já os parâmetros de saída, devido à função
que exercem, somente podem ser passados por
referência.
UFS - DComp - Prof. Kenia Kodel
program Multiplos;
const Q = 100;
var
V2, V3, V5, V7, V9: array [1..Q]
of integer;
Valor: integer;
I, I2, I3, I5, I7, I9: word;
begin
I2:=0; I3:=0; I5:=0; I7:=0; I9:=0;
writeln('Digite ',Q,' numeros:');
for I:=1 to Q do
begin
readln(Valor);
if (Valor mod 2=0) then
begin
inc(I2);
V2[I2]:=Valor;
end;
if (Valor mod 3=0) then
begin
inc(I3);
V3[I3]:=Valor;
end;
if (Valor mod 5=0) then
begin
inc(I5);
V5[I5]:=Valor;
end;
if (Valor mod 7=0) then
begin
inc(I7);
V7[I7]:=Valor;
end;
if (Valor mod 9=0) then
begin
inc(I9);
V9[I9]:=Valor;
end;
end;
writeln('Multiplos de 2');
for I:=1 to I2 do
writeln(V2[I]);
writeln('Multiplos de 3');
for I:=1 to I3 do
writeln(V3[I]);
writeln('Multiplos de 5');
for I:=1 to I5 do
writeln(V5[I]);
writeln('Multiplos de 7');
for I:=1 to I7 do
writeln(V7[I]);
writeln('Multiplos de 9');
for I:=1 to I9 do
writeln(V9[I]);
readln;
end.
Objetivo?
program Multiplos;
const Q = 100;
var
V2, V3, V5, V7, V9: array [1..Q]
of integer;
Valor: integer;
I, I2, I3, I5, I7, I9: word;
begin
I2:=0; I3:=0; I5:=0; I7:=0; I9:=0;
writeln('Digite ',Q,' numeros:');
for I:=1 to Q do
begin
readln(Valor);
if (Valor mod 2=0) then
begin
inc(I2);
V2[I2]:=Valor;
end;
if (Valor mod 3=0) then
begin
inc(I3);
V3[I3]:=Valor;
end;
if (Valor mod 5=0) then
begin
inc(I5);
V5[I5]:=Valor;
end;
if (Valor mod 7=0) then
begin
inc(I7);
V7[I7]:=Valor;
end;
if (Valor mod 9=0) then
begin
inc(I9);
V9[I9]:=Valor;
end;
end;
writeln('Multiplos de 2');
for I:=1 to I2 do
writeln(V2[I]);
writeln('Multiplos de 3');
for I:=1 to I3 do
writeln(V3[I]);
writeln('Multiplos de 5');
for I:=1 to I5 do
writeln(V5[I]);
writeln('Multiplos de 7');
for I:=1 to I7 do
writeln(V7[I]);
writeln('Multiplos de 9');
for I:=1 to I9 do
writeln(V9[I]);
readln;
end.
“Cabem” procedimentos?
program Multiplos;
const Q = 100;
type
TpVt= array [1..Q] of integer;
var
V2, V3, V5, V7, V9: TpVt;
Valor: integer;
I, I2, I3, I5, I7, I9: word;
procedure ComporVetor(N: byte;
V: integer;
var Vt: TpVt;
var T: byte);
begin
if (V mod N=0) then
begin
inc(T);
Vt[T]:=V;
end;
end;
begin
I2:=0; I3:=0; I5:=0; I7:=0; I9:=0;
writeln('Digite ',Q,' numeros:');
for I:=1 to Q do
begin
readln(Valor);
ComporVetor(2,Valor,V2,I2);
ComporVetor(3,Valor,V3,I3);
if (Valor mod 7=0) then
begin
inc(I7);
V7[I7]:=Valor;
end;
if (Valor mod 9=0) then
begin
inc(I9);
V9[I9]:=Valor;
end;
end;
writeln('Multiplos de 2');
for I:=1 to I2 do
writeln(V2[I]);
writeln('Multiplos de 3');
for I:=1 to I3 do
writeln(V3[I]);
writeln('Multiplos de 5');
for I:=1 to I5 do
writeln(V5[I]);
writeln('Multiplos de 7');
for I:=1 to I7 do
writeln(V7[I]);
...
O trecho de código destacado em
vermelho pode ser substituído pelo procedimento ComporVetor?
program Multiplos;
const Q = 100;
type
TpVt= array [1..Q] of integer;
var
V2, V3, V5, V7, V9: TpVt;
Valor: integer;
I, I2, I3, I5, I7, I9: word;
procedure ComporVetor(N: byte;
V: integer;
var Vt: TpVt;
var T: byte);
begin
if (V mod N=0) then
begin
inc(T);
Vt[T]:=V;
end;
end;
begin
I2:=0; I3:=0; I5:=0; I7:=0; I9:=0;
writeln('Digite ',Q,' numeros:');
for I:=1 to Q do
begin
readln(Valor);
ComporVetor(2,Valor,V2,I2);
ComporVetor(3,Valor,V3,I3);
ComporVetor(5,Valor,V5,I5);
ComporVetor(7,Valor,V7,I7);
ComporVetor(9,Valor,V9,I9);
end;
writeln('Multiplos de 2');
for I:=1 to I2 do
writeln(V2[I]);
writeln('Multiplos de 3');
for I:=1 to I3 do
writeln(V3[I]);
writeln('Multiplos de 5');
for I:=1 to I5 do
writeln(V5[I]);
writeln('Multiplos de 7');
for I:=1 to I7 do
writeln(V7[I]);
writeln('Multiplos de 9');
for I:=1 to I9 do
writeln(V9[I]);
readln;
end.
O tipo array, bem como o string, requer a definição de tipo correspondente, no type,
para ser usado como parâmetro.
program Multiplos;
const Q = 100;
type
TpVt= array [1..Q] of integer;
var
V2, V3, V5, V7, V9: TpVt;
Valor: integer;
I, I2, I3, I5, I7, I9: word;
procedure ComporVetor(N: byte;
V: integer;
var Vt: TpVt;
var T: byte);
begin
if (V mod N=0) then
begin
inc(T);
Vt[T]:=V;
end;
end;
begin
I2:=0; I3:=0; I5:=0; I7:=0; I9:=0;
writeln('Digite ',Q,' numeros:');
for I:=1 to Q do
begin
readln(Valor);
ComporVetor(2,Valor,V2,I2);
ComporVetor(3,Valor,V3,I3);
ComporVetor(5,Valor,V5,I5);
ComporVetor(7,Valor,V7,I7);
ComporVetor(9,Valor,V9,I9);
end;
writeln('Multiplos de 2');
for I:=1 to I2 do
writeln(V2[I]);
writeln('Multiplos de 3');
for I:=1 to I3 do
writeln(V3[I]);
writeln('Multiplos de 5');
for I:=1 to I5 do
writeln(V5[I]);
writeln('Multiplos de 7');
for I:=1 to I7 do
writeln(V7[I]);
writeln('Multiplos de 9');
for I:=1 to I9 do
writeln(V9[I]);
readln;
end. O programa dado está devidamente
modularizado?
program Multiplos;
const Q = 100;
type
TpVt= array [1..Q] of integer;
var
V2, V3, V5, V7, V9: TpVt;
Valor: integer;
I, I2, I3, I5, I7, I9: word;
procedure ComporVetor(N: byte;
V: integer;
var Vt: TpVt;
var T: byte);
begin
if (V mod N=0) then
begin
inc(T);
Vt[T]:=V;
end;
end;
procedure ExibeVetor(N: byte;
Vt: TpVt;
T: byte);
var
E: byte;
begin
writeln('Multiplos de ‘,N);
for E:=1 to T do
writeln(Vt[I]);
end;
begin
I2:=0; I3:=0; I5:=0; I7:=0; I9:=0;
writeln('Digite ',Q,' numeros:');
for I:=1 to Q do
begin
readln(Valor);
ComporVetor(2,Valor,V2,I2);
ComporVetor(3,Valor,V3,I3);
ComporVetor(5,Valor,V5,I5);
ComporVetor(7,Valor,V7,I7);
ComporVetor(9,Valor,V9,I9);
end;
ExibeVetor(2,V2,I2);
ExibeVetor(3,V3,I3);
writeln('Multiplos de 5');
for I:=1 to I5 do
writeln(V5[I]);
writeln('Multiplos de 7');
for I:=1 to I7 do
writeln(V7[I]);
writeln('Multiplos de 9');
for I:=1 to I9 do
writeln(V9[I]);
readln;
end. Agora o programa dado está devidamente
modularizado?
program Multiplos;
const Q = 100;
type
TpVt= array [1..Q] of integer;
var
V2, V3, V5, V7, V9: TpVt;
Valor: integer;
I, I2, I3, I5, I7, I9: word;
procedure ComporVetor(N: byte;
V: integer;
var Vt: TpVt;
var T: byte);
begin
if (V mod N=0) then
begin
inc(T);
Vt[T]:=V;
end;
end;
procedure ExibeVetor(N: byte;
Vt: TpVt;
T: byte);
var
E: byte;
begin
writeln('Multiplos de ‘,N);
for E:=1 to T do
writeln(Vt[I]);
end;
begin
I2:=0; I3:=0; I5:=0; I7:=0; I9:=0;
writeln('Digite ',Q,' numeros:');
for I:=1 to Q do
begin
readln(Valor);
ComporVetor(2,Valor,V2,I2);
ComporVetor(3,Valor,V3,I3);
ComporVetor(5,Valor,V5,I5);
ComporVetor(7,Valor,V7,I7);
ComporVetor(9,Valor,V9,I9);
end;
ExibeVetor(2,V2,I2);
ExibeVetor(3,V3,I3);
ExibeVetor(5,V5,I5);
ExibeVetor(7,V7,I7);
ExibeVetor(9,V9,I9);
readln;
end.
Este trecho do programa (entre o
begin e o end principais) é chamado programa principal.
UFS - DComp - Prof. Kenia Kodel
procedure ExibeMsg(Msg: Str70);
begin
{limpando area de mensagens}
gotoxy(7,22);
writeln(' ':70);
{exibindo orientacao}
gotoxy(7,22);
writeln(Msg);
end;
EXEMPLO Procedimento para exibir em tela mensagem dada (passada
como parâmetro), composta por até 70 caracteres na coluna
7, linha 22 :
UFS - DComp - Prof. Kenia Kodel
procedure ExibeMsg(Msg: Str70);
begin
{limpando area de mensagens}
gotoxy(7,22);
writeln(' ':70);
{exibindo orientacao}
gotoxy(7,22);
writeln(Msg);
end;
Procedimento para exibir em tela mensagem dada (passada como parâmetro),
composta por até 70 caracteres na coluna 7, linha 22 :
Construir procedimento para exibir em tela mensagem
dada, composta por N caracteres, na coluna C, linha
L. Sendo dados: mensagem, N, C e L.
EXERCÍCIO
UFS - DComp - Prof. Kenia Kodel
procedure ExibeMsg(Msg: string; N, C, L: byte);
begin
{limpando area de mensagens}
gotoxy(C,L);
writeln(' ':N);
{exibindo orientacao}
gotoxy(C,L);
writeln(Msg);
end;
Procedimento para exibir em tela mensagem dada (passada
como parâmetro), composta por até N caracteres na coluna
C, linha L :
Criar procedimento para incluir, com deslocamento
de dados, um elemento E numa dada posição P do
vetor V de tamanho T.
UFS - DComp - Prof. Kenia Kodel
Criar procedimento para implementar o subproblema
jogar do “adivinha sequencia GRB” (trabalhado em
aula anterior). É dada a sequência correta, e se
deseja o número de erros do jogador a partir da
leitura das 10 letras hipóteses do segundo
jogador.
UFS - DComp - Prof. Kenia Kodel
Criar procedimento denominado incremente para
adicionar uma unidade à variável passada como
parâmetro. Ou seja, criar procedimento similar ao
inc, quando usado com único parâmetro.
Proibido na elaboração deste usar o inc.
UFS - DComp - Prof. Kenia Kodel
Criar procedimento denominado decremente para
subtrair uma unidade da variável passada como
parâmetro. Ou seja, criar procedimento similar ao
dec, quando usado com único parâmetro.
Proibido na elaboração deste usaro dec.
UFS - DComp - Prof. Kenia Kodel
Criar procedimento denominado remove para implementar funcionalidade similar à do módulo predefinido delete o qual possibilita retirar Q caracteres de uma determinada string, passada como parâmetro, partindo da posição P definida: delete(var <identificador>:string; <P>, <Q>: integer);. Proibido, na elaboração deste, aplicar o delete.
UFS - DComp - Prof. Kenia Kodel
Criar procedimento denominado copia para implementar funcionalidade similar à do módulo predefinido copy o qual retorna uma substring de uma string passada como parâmetro, a partir da posição P inicial dada e com Q caracteres: copy(<ident>: string; <P>, <Q>: integer): string;. Proibido, na elaboração deste, aplicar o copy.
UFS - DComp - Prof. Kenia Kodel
Criar procedimento denominado insira para implementar funcionalidade similar à do módulo predefinido insert o qual permite inserir uma substring Sub em uma string S em uma posição P: insert(<Sub>: string; var <S>: string; <P>:integer);. Proibido, na elaboração deste, aplicar o insert.
UFS - DComp - Prof. Kenia Kodel
Os programas computacionais podem ser decompostos em programas menores denominados módulos, ou subprogramas.
Em Pascal há 2 tipos de módulos:
UFS - DComp - Prof. Kenia Kodel
Procedimentos procedure <Nome> [(parâmetro...)]; <declarações>; begin <comandos>; end;
Funções function <Nome>[(parâmetro...)]: <tipo>; <declarações>; begin <comandos>; <Nome> := <saída>; end;
Correspondem ao segundo tipo de módulo do Pascal. São declaradas:
function <Nome>[(parâmetro...)]: <tipo>;
<declarações>;
begin
<comandos>;
<Nome> := <saída>;
end;
Onde:
<Nome> nome da função
[(parâmetro...)] relação de parâmetros
<tipo> tipo do resultado da função
<declarações>; declaração de tipos, variáveis, constantes e módulos locais
<comandos>; comando ou bloco de comando
<Nome> := <saída>; definição do retorno da função; onde saída é do tipo <tipo>
UFS - DComp - Prof. Kenia Kodel
program Multiplos;
uses CRT;
const Q = 10;
type TpVt= array [1..Q] of integer;
var
Vetor: TpVt;
I, Quant: word;
function ContaMultiplos(V: TpVt; M: byte):byte;
var
Aux,
J:byte;
begin
Aux:=0;
for J:=1 to Q do
if (V[J] mod M = 0) then
inc(Aux);
ContaMultiplos:=Aux;
end;
begin
writeln('Digite ',Q,' numeros:');
for I:=1 to Q do readln(Vetor[I]);
Quant:=ContaMultiplos(Vetor,2);
writeln('Quantidade de multiplos de 2: ',Quant);
writeln('Quantidade de multiplos de 3: ',ContaMultiplos(Vetor,3));
writeln('Quantidade de multiplos de 5: ',ContaMultiplos(Vetor,5));
writeln('Quantidade de multiplos de 7: ',ContaMultiplos(Vetor,7));
writeln('Quantidade de multiplos de 9: ',ContaMultiplos(Vetor,9));
readln;
end.
Objetivo?
program Multiplos;
uses CRT;
const Q = 10;
type TpVt= array [1..Q] of integer;
var
Vetor: TpVt;
I, Quant: word;
function ContaMultiplos(V: TpVt; M: byte):byte;
var
Aux,
J:byte;
begin
Aux:=0;
for J:=1 to Q do
if (V[J] mod M = 0) then
inc(Aux);
ContaMultiplos:=Aux;
end;
begin
writeln('Digite ',Q,' numeros:');
for I:=1 to Q do readln(Vetor[I]);
Quant:=ContaMultiplos(Vetor,2);
writeln('Quantidade de multiplos de 2: ',Quant);
writeln('Quantidade de multiplos de 3: ',ContaMultiplos(Vetor,3));
writeln('Quantidade de multiplos de 5: ',ContaMultiplos(Vetor,5));
writeln('Quantidade de multiplos de 7: ',ContaMultiplos(Vetor,7));
writeln('Quantidade de multiplos de 9: ',ContaMultiplos(Vetor,9));
readln;
end.
As funções funcionam
como nos procedimentos:
• os escopos,
• os parâmetros e
• as passagens de
parâmetros.
O que os distingue é a
forma de chamada.
program Multiplos;
uses CRT;
const Q = 10;
type TpVt= array [1..Q] of integer;
var
Vetor: TpVt;
I, Quant: word;
function ContaMultiplos(V: TpVt; M: byte):byte;
var
Aux,
J:byte;
begin
Aux:=0;
for J:=1 to Q do
if (V[J] mod M = 0) then
inc(Aux);
ContaMultiplos:=Aux;
end;
begin
writeln('Digite ',Q,' numeros:');
for I:=1 to Q do readln(Vetor[I]);
Quant:=ContaMultiplos(Vetor,2);
writeln('Quantidade de multiplos de 2: ',Quant);
writeln('Quantidade de multiplos de 3: ',ContaMultiplos(Vetor,3));
writeln('Quantidade de multiplos de 5: ',ContaMultiplos(Vetor,5));
writeln('Quantidade de multiplos de 7: ',ContaMultiplos(Vetor,7));
writeln('Quantidade de multiplos de 9: ',ContaMultiplos(Vetor,9));
readln;
end.
Quanto aos escopos, na
função exemplo dada: Q
é constante global. E
Aux e J são variáveis
locais.
program Multiplos;
uses CRT;
const Q = 10;
type TpVt= array [1..Q] of integer;
var
Vetor: TpVt;
I, Quant: word;
function ContaMultiplos(V: TpVt; M: byte):byte;
var
Aux,
J:byte;
begin
Aux:=0;
for J:=1 to Q do
if (V[J] mod M = 0) then
inc(Aux);
ContaMultiplos:=Aux;
end;
begin
writeln('Digite ',Q,' numeros:');
for I:=1 to Q do readln(Vetor[I]);
Quant:=ContaMultiplos(Vetor,2);
writeln('Quantidade de multiplos de 2: ',Quant);
writeln('Quantidade de multiplos de 3: ',ContaMultiplos(Vetor,3));
writeln('Quantidade de multiplos de 5: ',ContaMultiplos(Vetor,5));
writeln('Quantidade de multiplos de 7: ',ContaMultiplos(Vetor,7));
writeln('Quantidade de multiplos de 9: ',ContaMultiplos(Vetor,9));
readln;
end.
Quanto aos parâmetros, na função exemplo dada, V e M são de entrada. A saída da referida função é do tipo byte. Há ainda a possibilidade de haver parâmetros de saída.
program Multiplos;
uses CRT;
const Q = 10;
type TpVt= array [1..Q] of integer;
var
Vetor: TpVt;
I, Quant: word;
function ContaMultiplos(V: TpVt; M: byte):byte;
var
Aux,
J:byte;
begin
Aux:=0;
for J:=1 to Q do
if (V[J] mod M = 0) then
inc(Aux);
ContaMultiplos:=Aux;
end;
begin
writeln('Digite ',Q,' numeros:');
for I:=1 to Q do readln(Vetor[I]);
Quant:=ContaMultiplos(Vetor,2); writeln('Quantidade de multiplos de 2: ',Quant);
writeln('Quantidade de multiplos de 3: ',ContaMultiplos(Vetor,3));
writeln('Quantidade de multiplos de 5: ',ContaMultiplos(Vetor,5));
writeln('Quantidade de multiplos de 7: ',ContaMultiplos(Vetor,7));
writeln('Quantidade de multiplos de 9: ',ContaMultiplos(Vetor,9));
readln;
end.
Quanto à passagem de parâmetros, nas diversas chamadas, a primeira passagem é por referência e a segunda é por valor.
program Multiplos;
uses CRT;
const Q = 10;
type TpVt= array [1..Q] of integer;
var
Vetor: TpVt;
I, Quant: word;
function ContaMultiplos(V: TpVt; M: byte):byte;
var
Aux,
J:byte;
begin
Aux:=0;
for J:=1 to Q do
if (V[J] mod M = 0) then
inc(Aux);
ContaMultiplos:=Aux;
end;
begin
writeln('Digite ',Q,' numeros:');
for I:=1 to Q do readln(Vetor[I]);
Quant:=ContaMultiplos(Vetor,2); writeln('Quantidade de multiplos de 2: ',Quant);
writeln('Quantidade de multiplos de 3: ',ContaMultiplos(Vetor,3));
writeln('Quantidade de multiplos de 5: ',ContaMultiplos(Vetor,5));
writeln('Quantidade de multiplos de 7: ',ContaMultiplos(Vetor,7));
writeln('Quantidade de multiplos de 9: ',ContaMultiplos(Vetor,9));
readln;
end.
Observar que as chamadas das
funções não são como as dos
procedimentos.
Os procedimentos são chamados como um
comando isolado, numa linha de código
próprio.
UFS - DComp - Prof. Kenia Kodel
Nas funções, os escopos, os parâmetros e as passagens de parâmetros funcionam como nos procedimentos, inclusive parâmetros de saída. O que os distingue é a forma de chamada.
As funções são chamadas conjuntamente à
instrução de atribuição, bem como argumento do
writeln, e para definição do teto do for. Devem ser
atribuídas a uma variável de mesmo tipo de seu
resultado.
UFS - DComp - Prof. Kenia Kodel
Exemplo: função para cálculo do fatorial. function Fatorial(X: integer):integer;
var I, Aux: integer;
begin
Aux:=1; for I:=1 to X do
Aux:=Aux * I;
Fatorial:=Aux; end;
UFS - DComp - Prof. Kenia Kodel
Considerando a função dada, qual o valor de A, sendo:
A:=Fatorial(4);
Exemplo: função para cálculo do fatorial. function Fatorial(X: integer):integer;
var
I, Aux: integer;
begin
Aux:=1;
for I:=1 to X do
Aux:=Aux * I;
Fatorial:=Aux;
end;
UFS - DComp - Prof. Kenia Kodel
Sem aplicar a função dada, escrever código Pascal para calcular:
Exemplo: função para cálculo do fatorial. function Fatorial(X: integer):integer;
var
I, Aux: integer;
begin
Aux:=1;
for I:=1 to X do
Aux:=Aux * I;
Fatorial:=Aux;
end;
UFS - DComp - Prof. Kenia Kodel
Aplicando a função dada, escrever código Pascal para calcular:
Exemplo: função para cálculo do fatorial. function Fatorial(X: integer):integer;
var
I, Aux: integer;
begin
Aux:=1;
for I:=1 to X do
Aux:=Aux * I;
Fatorial:=Aux;
end;
UFS - DComp - Prof. Kenia Kodel
Aplicando a função dada, escrever código Pascal para calcular R:
R = N! / (K! * (N-K)!)
Exemplo: função para cálculo do fatorial. function Fatorial(X: integer):integer;
var
I, Aux: integer;
begin
Aux:=1;
for I:=1 to X do
Aux:=Aux * I;
Fatorial:=Aux;
end;
UFS - DComp - Prof. Kenia Kodel
Considerando esta função, tem-se para o cálculo de:
R = N! / (K! * (N-K)!);
readln(N,K);
R:=Fatorial(N)/(Fatorial(K)
*Fatorial(N-k));
writeln(R);
Porque modularização:
Evita redundância de código
Melhora a legibilidade dos programas
Possibilita a reutilização de código; o
que otimiza a aplicação de esforços.
UFS - DComp - Prof. Kenia Kodel
Criar função para retornar o maior valor de
um dado vetor.
UFS - DComp - Prof. Kenia Kodel
Criar função para retornar a posição que um
novo dado D deve ocupar num dado vetor
V ordenado.
UFS - DComp - Prof. Kenia Kodel
Reescrever o projeto da LanHouse usando
procedimentos e funções de forma a evitar
redundância de código e a otimizar a
legibilidade do programa.
UFS - DComp - Prof. Kenia Kodel
Escrever função Pascal com função similar à
função predefinida odd.
UFS - DComp - Prof. Kenia Kodel
Escrever função Pascal com função similar à
função predefinida pos.
UFS - DComp - Prof. Kenia Kodel
76
UFS - DComp - Prof. Kenia Kodel
MODULARIZAÇÃO COMPLEMENTAR ESTUDOS:
Fundamentos da Programação de Computadores
Ana Fernanda Gomes Ascencio
Edilene Aparecida Veneruchi de Campos
Capítulo Sub-Rotinas