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.

program SucessorAntecessor;

Numero: integer;

Opcao: char;

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;

'2': begin

dec(Numero);

writeln;

writeln('Antecessor: ',Numero);

readln;

'3': begin

writeln;

writeln('Digite outro numero: ');

readln(Numero);

until Opcao = #27;

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

<comandos>;

2. Funções function <Nome>[(parâmetro...)]: <tipo>;

<declarações>;

<comandos>;

<Nome> := <saída>;

procedure <Nome> [(parâmetro...)];

<declarações>;

<comandos>;

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

Q = 100;

{Quantidade total de numeros}

Vetor: array [1..Q] of integer;

I: word;

{ocupa 2 byte, valores de 0 a 65.535}

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;

Qual o objetivo (funcionalidade) deste?

program Multiplos;

Q = 100;

I: word;

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;

Há subproblemas neste?

Usar procedimento para “empacotar” a solução dada aos subproblemas da questão em tela.

procedure <Nome> [(parâmetro...)];

<declarações>;

<comandos>;

for I:=1 to Q do

writeln(Vetor[I]);

for I:=1 to Q do

writeln(Vetor[I]);

procedure ExibeMultiplos(N: byte);

writeln('Multiplos de ',N);

for I:=1 to Q do

if (Vetor[I] mod N=0) then

writeln(Vetor[I]);

program Multiplos;

Q = 100;

I: word;

for I:=1 to Q do

writeln(Vetor[I]);

clrscr;

for I:=1 to Q do

readln(Vetor[I]);

ExibeMultiplos(2);

ExibeMultiplos(3);

ExibeMultiplos(5);

ExibeMultiplos(7);

ExibeMultiplos(9);

ExibeMultiplos(11);

readln;

Rastrear.

program Multiplos;

Q = 100;

I: word;

procedure ExibeMultiplos(N:

byte);

for I:=1 to Q do

writeln(Vetor[I]);

clrscr;

for I:=1 to Q do

readln(Vetor[I]);

ExibeMultiplos(2);

ExibeMultiplos(3);

ExibeMultiplos(5);

ExibeMultiplos(7);

ExibeMultiplos(9);

ExibeMultiplos(11);

readln;

A definição de um procedimento deve ser efetuada dentre as declarações do programa (principal).

program Multiplos;

Q = 100;

I: word;

for I:=1 to Q do

writeln(Vetor[I]);

clrscr;

for I:=1 to Q do

readln(Vetor[I]);

ExibeMultiplos(2);

ExibeMultiplos(3);

ExibeMultiplos(5);

ExibeMultiplos(7);

ExibeMultiplos(9);

ExibeMultiplos(11);

readln;

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;

Q = 100;

I: word;

for I:=1 to Q do

writeln(Vetor[I]);

clrscr;

for I:=1 to Q do

readln(Vetor[I]);

ExibeMultiplos(2);

ExibeMultiplos(3);

ExibeMultiplos(5);

ExibeMultiplos(7);

ExibeMultiplos(9);

ExibeMultiplos(11);

readln;

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;

Q = 100;

I: word;

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;

Q = 100;

I: word;

for I:=1 to Q do

writeln(Vetor[I]);

clrscr;

for I:=1 to Q do

readln(Vetor[I]);

ExibeMultiplos(2);

ExibeMultiplos(3);

ExibeMultiplos(5);

ExibeMultiplos(7);

ExibeMultiplos(9);

ExibeMultiplos(11);

readln;

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;

Q = 100;

I: word;

for I:=1 to Q do

writeln(Vetor[I]);

clrscr;

for I:=1 to Q do

readln(Vetor[I]);

ExibeMultiplos(2);

ExibeMultiplos(3);

ExibeMultiplos(5);

ExibeMultiplos(7);

ExibeMultiplos(9);

ExibeMultiplos(11);

readln;

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.

program SucessorAntecessor;

Numero: integer;

Opcao: char;

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;

'2': begin

dec(Numero);

writeln;

writeln('Antecessor: ',Numero);

readln;

'3': begin

writeln;

writeln('Digite outro numero: ');

readln(Numero);

until Opcao = #27;

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;

Q = 100;

I: word;

for I:=1 to Q do

writeln(Vetor[I]);

clrscr;

for I:=1 to Q do

readln(Vetor[I]);

ExibeMultiplos(2);

ExibeMultiplos(3);

ExibeMultiplos(5);

ExibeMultiplos(7);

ExibeMultiplos(9);

ExibeMultiplos(11);

readln;

Neste exemplo observa-

se o uso de elementos

globais somente.

program Multiplos;

Q = 100;

I: word;

for I:=1 to Q do

writeln(Vetor[I]);

clrscr;

for I:=1 to Q do

readln(Vetor[I]);

ExibeMultiplos(2);

ExibeMultiplos(3);

ExibeMultiplos(5);

ExibeMultiplos(7);

ExibeMultiplos(9);

ExibeMultiplos(11);

readln;

Ajustar o código de

forma a exibir a

quantidade de múltiplos.

program Multiplos;

Q = 100;

I: word;

Contador: byte;

Contador:=0;

for I:=1 to Q do

writeln(Vetor[I]);

inc(Contador);

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

clrscr;

for I:=1 to Q do

readln(Vetor[I]);

ExibeMultiplos(2);

ExibeMultiplos(3);

ExibeMultiplos(5);

ExibeMultiplos(7);

ExibeMultiplos(9);

ExibeMultiplos(11);

readln;

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.

Contador: byte;

Contador:=0;

for I:=1 to Q do

writeln(Vetor[I]);

inc(Contador);

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

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.

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

Delta: real;

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;

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

var r1, r2: real;

var id: char);

Delta: real;

else begin

id:=‘R’;

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

Delta: real;

else begin

id:=‘R’;

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

Delta: real;

else begin

id:=‘R’;

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

Delta: real;

else begin

id:=‘R’;

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;

V2, V3, V5, V7, V9: array [1..Q]

of integer;

Valor: integer;

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

I2:=0; I3:=0; I5:=0; I7:=0; I9:=0;

for I:=1 to Q do

readln(Valor);

if (Valor mod 2=0) then

inc(I2);

V2[I2]:=Valor;

inc(I3);

V3[I3]:=Valor;

inc(I5);

V5[I5]:=Valor;

inc(I7);

V7[I7]:=Valor;

inc(I9);

V9[I9]:=Valor;

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;

Objetivo?

program Multiplos;

const Q = 100;

V2, V3, V5, V7, V9: array [1..Q]

of integer;

Valor: integer;

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

I2:=0; I3:=0; I5:=0; I7:=0; I9:=0;

for I:=1 to Q do

readln(Valor);

inc(I2);

V2[I2]:=Valor;

inc(I3);

V3[I3]:=Valor;

inc(I5);

V5[I5]:=Valor;

inc(I7);

V7[I7]:=Valor;

inc(I9);

V9[I9]:=Valor;

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;

“Cabem” procedimentos?

program Multiplos;

const Q = 100;

TpVt= array [1..Q] of integer;

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

if (V mod N=0) then

inc(T);

Vt[T]:=V;

I2:=0; I3:=0; I5:=0; I7:=0; I9:=0;

for I:=1 to Q do

readln(Valor);

ComporVetor(2,Valor,V2,I2);

inc(I7);

V7[I7]:=Valor;

inc(I9);

V9[I9]:=Valor;

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;

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

Valor: integer;

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

V: integer;

var Vt: TpVt;

var T: byte);

if (V mod N=0) then

inc(T);

Vt[T]:=V;

I2:=0; I3:=0; I5:=0; I7:=0; I9:=0;

for I:=1 to Q do

readln(Valor);

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;

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;

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

Valor: integer;

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

V: integer;

var Vt: TpVt;

var T: byte);

if (V mod N=0) then

inc(T);

Vt[T]:=V;

I2:=0; I3:=0; I5:=0; I7:=0; I9:=0;

for I:=1 to Q do

readln(Valor);

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;

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

Valor: integer;

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

V: integer;

var Vt: TpVt;

var T: byte);

if (V mod N=0) then

inc(T);

Vt[T]:=V;

procedure ExibeVetor(N: byte;

Vt: TpVt;

T: byte);

E: byte;

writeln('Multiplos de ‘,N);

for E:=1 to T do

writeln(Vt[I]);

I2:=0; I3:=0; I5:=0; I7:=0; I9:=0;

for I:=1 to Q do

readln(Valor);

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;

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

Valor: integer;

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

V: integer;

var Vt: TpVt;

var T: byte);

if (V mod N=0) then

inc(T);

Vt[T]:=V;

procedure ExibeVetor(N: byte;

Vt: TpVt;

T: byte);

E: byte;

writeln('Multiplos de ‘,N);

for E:=1 to T do

writeln(Vt[I]);

I2:=0; I3:=0; I5:=0; I7:=0; I9:=0;

for I:=1 to Q do

readln(Valor);

readln;

Este trecho do programa (entre o

begin e o end principais) é chamado programa principal.

procedure ExibeMsg(Msg: Str70);

{limpando area de mensagens}

gotoxy(7,22);

writeln(' ':70);

{exibindo orientacao}

gotoxy(7,22);

writeln(Msg);

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

gotoxy(7,22);

writeln(' ':70);

gotoxy(7,22);

writeln(Msg);

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

gotoxy(C,L);

writeln(' ':N);

gotoxy(C,L);

writeln(Msg);

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

<comandos>;

<Nome> := <saída>;

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

Vetor: TpVt;

I, Quant: word;

function ContaMultiplos(V: TpVt; M: byte):byte;

J:byte;

Aux:=0;

for J:=1 to Q do

if (V[J] mod M = 0) then

inc(Aux);

ContaMultiplos:=Aux;

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;

Objetivo?

program Multiplos;

uses CRT;

const Q = 10;

Vetor: TpVt;

I, Quant: word;

J:byte;

Aux:=0;

for J:=1 to Q do

inc(Aux);

readln;

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;

Vetor: TpVt;

I, Quant: word;

J:byte;

Aux:=0;

for J:=1 to Q do

inc(Aux);

readln;

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;

Vetor: TpVt;

I, Quant: word;

J:byte;

Aux:=0;

for J:=1 to Q do

inc(Aux);

readln;

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;

Vetor: TpVt;

I, Quant: word;

J:byte;

Aux:=0;

for J:=1 to Q do

inc(Aux);

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

readln;

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;

Vetor: TpVt;

I, Quant: word;

J:byte;

Aux:=0;

for J:=1 to Q do

inc(Aux);

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

readln;

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;

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

I, Aux: integer;

Aux:=1;

for I:=1 to X do

Aux:=Aux * I;

Fatorial:=Aux;

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

I, Aux: integer;

Aux:=1;

for I:=1 to X do

Aux:=Aux * I;

Fatorial:=Aux;

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

I, Aux: integer;

Aux:=1;

for I:=1 to X do

Aux:=Aux * I;

Fatorial:=Aux;

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

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

I, Aux: integer;

Aux:=1;

for I:=1 to X do

Aux:=Aux * I;

Fatorial:=Aux;

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.

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

modularização de programas parte...

modularizaÇÃo e os efeitos no processo...

modularizacÃo de projeto estruturado de sistemas … ·...

técnicas de desenvolvimento de programas função....

linguagens de programação -...

hergen padronizaÇÃo & modularizaÇÃo

descritivo do serviÇo vivo cloud (anexo às condições...

análise e projeto de sistemas (cont.) · projeto...

modularização -...

capítulo iii modularização procedimentos e funções...

algoritmos e estruturas de dados i – modularização...

modularização e design

profa. mercedes gonzales márquez algoritmos e estruturas de...

modularização programação em java prof. maurício braga

modularização via bpl - abordagem prática para datasnap &...

conceitos básicos de...

conceitos básicos de...

standardização e modularização dos cilindros...

modularização em lp

aula 4 modularização: funções e procedimentos...