pimperativa08 - modularização
DESCRIPTION
tutorial de modularização PITRANSCRIPT
![Page 1: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/1.jpg)
Programação Imperativa Unidade 8
UFS - DComp - Prof. Kenia Kodel
![Page 2: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/2.jpg)
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
![Page 3: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/3.jpg)
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
![Page 4: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/4.jpg)
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
![Page 5: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/5.jpg)
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
![Page 6: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/6.jpg)
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
![Page 7: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/7.jpg)
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
![Page 8: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/8.jpg)
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?
![Page 9: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/9.jpg)
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?
![Page 10: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/10.jpg)
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;
![Page 11: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/11.jpg)
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.
![Page 12: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/12.jpg)
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).
![Page 13: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/13.jpg)
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.
![Page 14: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/14.jpg)
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.
![Page 15: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/15.jpg)
Usando procedimentos, evita-se redundância de código.
![Page 16: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/16.jpg)
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?
![Page 17: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/17.jpg)
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?
![Page 18: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/18.jpg)
Usando procedimentos, facilita-se a manutenção de programas computacionais.
![Page 19: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/19.jpg)
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.
![Page 20: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/20.jpg)
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
![Page 21: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/21.jpg)
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?
![Page 22: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/22.jpg)
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
![Page 23: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/23.jpg)
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.
![Page 24: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/24.jpg)
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.
![Page 25: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/25.jpg)
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.
![Page 26: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/26.jpg)
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.
![Page 27: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/27.jpg)
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.
![Page 28: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/28.jpg)
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
![Page 29: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/29.jpg)
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
![Page 30: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/30.jpg)
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
![Page 31: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/31.jpg)
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?
![Page 32: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/32.jpg)
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
![Page 33: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/33.jpg)
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.
![Page 34: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/34.jpg)
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.
![Page 35: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/35.jpg)
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
![Page 36: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/36.jpg)
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);
![Page 37: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/37.jpg)
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
![Page 38: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/38.jpg)
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?
![Page 39: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/39.jpg)
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?
![Page 40: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/40.jpg)
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?
![Page 41: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/41.jpg)
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.
![Page 42: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/42.jpg)
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?
![Page 43: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/43.jpg)
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?
![Page 44: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/44.jpg)
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.
![Page 45: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/45.jpg)
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 :
![Page 46: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/46.jpg)
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
![Page 47: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/47.jpg)
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 :
![Page 48: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/48.jpg)
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
![Page 49: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/49.jpg)
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
![Page 50: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/50.jpg)
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
![Page 51: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/51.jpg)
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
![Page 52: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/52.jpg)
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
![Page 53: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/53.jpg)
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
![Page 54: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/54.jpg)
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
![Page 55: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/55.jpg)
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;
![Page 56: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/56.jpg)
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
![Page 57: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/57.jpg)
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?
![Page 58: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/58.jpg)
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.
![Page 59: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/59.jpg)
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.
![Page 60: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/60.jpg)
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.
![Page 61: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/61.jpg)
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.
![Page 62: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/62.jpg)
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.
![Page 63: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/63.jpg)
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.
![Page 64: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/64.jpg)
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
![Page 65: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/65.jpg)
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);
![Page 66: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/66.jpg)
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:
![Page 67: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/67.jpg)
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:
![Page 68: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/68.jpg)
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)!)
![Page 69: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/69.jpg)
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);
![Page 70: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/70.jpg)
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
![Page 71: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/71.jpg)
Criar função para retornar o maior valor de
um dado vetor.
UFS - DComp - Prof. Kenia Kodel
![Page 72: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/72.jpg)
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
![Page 73: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/73.jpg)
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
![Page 74: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/74.jpg)
Escrever função Pascal com função similar à
função predefinida odd.
UFS - DComp - Prof. Kenia Kodel
![Page 75: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/75.jpg)
Escrever função Pascal com função similar à
função predefinida pos.
UFS - DComp - Prof. Kenia Kodel
![Page 76: PImperativa08 - Modularização](https://reader034.vdocuments.mx/reader034/viewer/2022051419/55cf9334550346f57b9cb1b0/html5/thumbnails/76.jpg)
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