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.


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 -

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);


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.


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;


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.


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]);



for I:=1 to Q do


writeln(Vetor[I]);


for I:=1 to Q do


writeln(Vetor[I]);


for I:=1 to Q do


writeln(Vetor[I]);


for I:=1 to Q do


writeln(Vetor[I]);


for I:=1 to Q do


writeln(Vetor[I]);

readln;

end.

Qual o objetivo (funcionalidade) deste?

program Multiplos;

uses

CRT;

const

Q = 100;


var


I: word;


begin

clrscr;


for I:=1 to Q do

readln(Vetor[I]);


for I:=1 to Q do


writeln(Vetor[I]);



for I:=1 to Q do


writeln(Vetor[I]);


for I:=1 to Q do


writeln(Vetor[I]);


for I:=1 to Q do


writeln(Vetor[I]);


for I:=1 to Q do


writeln(Vetor[I]);


for I:=1 to Q do


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;

...


for I:=1 to Q do


writeln(Vetor[I]);


for I:=1 to Q do


writeln(Vetor[I]);

...


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;


var


I: word;



begin


for I:=1 to Q do


writeln(Vetor[I]);

end;


begin

clrscr;


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;


var


I: word;


procedure ExibeMultiplos(N:

byte);

begin


for I:=1 to Q do


writeln(Vetor[I]);

end;


begin

clrscr;


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;


var


I: word;



begin


for I:=1 to Q do


writeln(Vetor[I]);

end;


begin

clrscr;


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;


var


I: word;



begin


for I:=1 to Q do


writeln(Vetor[I]);

end;


begin

clrscr;


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;


var


I: word;


begin

clrscr;


for I:=1 to Q do

readln(Vetor[I]);


for I:=1 to Q do


writeln(Vetor[I]);



for I:=1 to Q do


writeln(Vetor[I]);


for I:=1 to Q do


writeln(Vetor[I]);


for I:=1 to Q do


writeln(Vetor[I]);


for I:=1 to Q do


writeln(Vetor[I]);


for I:=1 to Q do


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;


var


I: word;



begin


for I:=1 to Q do


writeln(Vetor[I]);

end;


begin

clrscr;


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;


var


I: word;



begin


for I:=1 to Q do


writeln(Vetor[I]);

end;


begin

clrscr;


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 -

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);


readln;

end;

'2': begin

dec(Numero);

writeln;

writeln('Antecessor: ',Numero);


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.


program Multiplos;

uses

CRT;

const

Q = 100;


var


I: word;



begin


for I:=1 to Q do


writeln(Vetor[I]);

end;


begin

clrscr;


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;


var


I: word;



begin


for I:=1 to Q do


writeln(Vetor[I]);

end;


begin

clrscr;


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


I: word;



var

Contador: byte;

begin

Contador:=0;


for I:=1 to Q do


begin

writeln(Vetor[I]);

inc(Contador);

end;

writeln(‘Ha ’,Contador,’ multiplos’);

end;


begin

clrscr;


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.


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.


var

Contador: byte;

begin

Contador:=0;


for I:=1 to Q do


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.


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.


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);

...


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;


Quais os parâmetros de entrada e os de saída?


var r1, r2: real;

var id: char);

var

Delta: real;

begin



else begin

id:=‘R’;



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.



var r1, r2: real;

var id: char);

var

Delta: real;

begin



else begin

id:=‘R’;



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.


var r1, r2: real;

var id: char);

var

Delta: real;

begin



else begin

id:=‘R’;



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



var r1, r2: real;

var id: char);

var

Delta: real;

begin



else begin

id:=‘R’;



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.


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;


for I:=1 to Q do

begin

readln(Valor);

if (Valor mod 2=0) then

begin

inc(I2);

V2[I2]:=Valor;

end;


begin

inc(I3);

V3[I3]:=Valor;

end;


begin

inc(I5);

V5[I5]:=Valor;

end;


begin

inc(I7);

V7[I7]:=Valor;

end;


begin

inc(I9);

V9[I9]:=Valor;

end;

end;


for I:=1 to I2 do

writeln(V2[I]);


for I:=1 to I3 do

writeln(V3[I]);


for I:=1 to I5 do

writeln(V5[I]);


for I:=1 to I7 do

writeln(V7[I]);


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;


for I:=1 to Q do

begin

readln(Valor);


begin

inc(I2);

V2[I2]:=Valor;

end;


begin

inc(I3);

V3[I3]:=Valor;

end;


begin

inc(I5);

V5[I5]:=Valor;

end;


begin

inc(I7);

V7[I7]:=Valor;

end;


begin

inc(I9);

V9[I9]:=Valor;

end;

end;


for I:=1 to I2 do

writeln(V2[I]);


for I:=1 to I3 do

writeln(V3[I]);


for I:=1 to I5 do

writeln(V5[I]);


for I:=1 to I7 do

writeln(V7[I]);


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;


for I:=1 to Q do

begin

readln(Valor);

ComporVetor(2,Valor,V2,I2);



begin

inc(I7);

V7[I7]:=Valor;

end;


begin

inc(I9);

V9[I9]:=Valor;

end;

end;


for I:=1 to I2 do

writeln(V2[I]);


for I:=1 to I3 do

writeln(V3[I]);


for I:=1 to I5 do

writeln(V5[I]);


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


var

V2, V3, V5, V7, V9: TpVt;

Valor: integer;

I, I2, I3, I5, I7, I9: word;


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;


for I:=1 to Q do

begin

readln(Valor);






end;


for I:=1 to I2 do

writeln(V2[I]);


for I:=1 to I3 do

writeln(V3[I]);


for I:=1 to I5 do

writeln(V5[I]);


for I:=1 to I7 do

writeln(V7[I]);


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


var

V2, V3, V5, V7, V9: TpVt;

Valor: integer;

I, I2, I3, I5, I7, I9: word;


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;


for I:=1 to Q do

begin

readln(Valor);






end;


for I:=1 to I2 do

writeln(V2[I]);


for I:=1 to I3 do

writeln(V3[I]);


for I:=1 to I5 do

writeln(V5[I]);


for I:=1 to I7 do

writeln(V7[I]);


for I:=1 to I9 do

writeln(V9[I]);

readln;

end. O programa dado está devidamente

modularizado?

program Multiplos;

const Q = 100;

type


var

V2, V3, V5, V7, V9: TpVt;

Valor: integer;

I, I2, I3, I5, I7, I9: word;


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;


for I:=1 to Q do

begin

readln(Valor);






end;

ExibeVetor(2,V2,I2);



for I:=1 to I5 do

writeln(V5[I]);


for I:=1 to I7 do

writeln(V7[I]);


for I:=1 to I9 do

writeln(V9[I]);

readln;

end. Agora o programa dado está devidamente

modularizado?

program Multiplos;

const Q = 100;

type


var

V2, V3, V5, V7, V9: TpVt;

Valor: integer;

I, I2, I3, I5, I7, I9: word;


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;


for I:=1 to Q do

begin

readln(Valor);






end;






readln;

end.

Este trecho do programa (entre o

begin e o end principais) é chamado programa principal.


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 :


procedure ExibeMsg(Msg: Str70);

begin


gotoxy(7,22);

writeln(' ':70);


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


procedure ExibeMsg(Msg: string; N, C, L: byte);

begin


gotoxy(C,L);

writeln(' ':N);


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.


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.


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.


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.


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.


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.


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.


Os programas computacionais podem ser decompostos em programas menores denominados módulos, ou subprogramas.

Em Pascal há 2 tipos de módulos:


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>


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


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));




readln;

end.

Objetivo?

program Multiplos;

uses CRT;

const Q = 10;


var

Vetor: TpVt;

I, Quant: word;


var

Aux,

J:byte;

begin

Aux:=0;

for J:=1 to Q do


inc(Aux);


end;

begin









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;


var

Vetor: TpVt;

I, Quant: word;


var

Aux,

J:byte;

begin

Aux:=0;

for J:=1 to Q do


inc(Aux);


end;

begin









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;


var

Vetor: TpVt;

I, Quant: word;


var

Aux,

J:byte;

begin

Aux:=0;

for J:=1 to Q do


inc(Aux);


end;

begin









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;


var

Vetor: TpVt;

I, Quant: word;


var

Aux,

J:byte;

begin

Aux:=0;

for J:=1 to Q do


inc(Aux);


end;

begin



Quant:=ContaMultiplos(Vetor,2); writeln('Quantidade de multiplos de 2: ',Quant);





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;


var

Vetor: TpVt;

I, Quant: word;


var

Aux,

J:byte;

begin

Aux:=0;

for J:=1 to Q do


inc(Aux);


end;

begin



Quant:=ContaMultiplos(Vetor,2); writeln('Quantidade de multiplos de 2: ',Quant);





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.


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.


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;


Considerando a função dada, qual o valor de A, sendo:

A:=Fatorial(4);


var

I, Aux: integer;

begin

Aux:=1;

for I:=1 to X do

Aux:=Aux * I;

Fatorial:=Aux;

end;


Sem aplicar a função dada, escrever código Pascal para calcular:


var

I, Aux: integer;

begin

Aux:=1;

for I:=1 to X do

Aux:=Aux * I;

Fatorial:=Aux;

end;


Aplicando a função dada, escrever código Pascal para calcular:


var

I, Aux: integer;

begin

Aux:=1;

for I:=1 to X do

Aux:=Aux * I;

Fatorial:=Aux;

end;


Aplicando a função dada, escrever código Pascal para calcular R:

R = N! / (K! * (N-K)!)


var

I, Aux: integer;

begin

Aux:=1;

for I:=1 to X do

Aux:=Aux * I;

Fatorial:=Aux;

end;


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.


Criar função para retornar o maior valor de

um dado vetor.


Criar função para retornar a posição que um

novo dado D deve ocupar num dado vetor

V ordenado.


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.


Escrever função Pascal com função similar à

função predefinida odd.


Escrever função Pascal com função similar à

função predefinida pos.


76


MODULARIZAÇÃO COMPLEMENTAR ESTUDOS:

Fundamentos da Programação de Computadores

Ana Fernanda Gomes Ascencio

Edilene Aparecida Veneruchi de Campos

Capítulo Sub-Rotinas

pimperativa08 - modularização

Documents