Aula_005 - Procedimentos

Prévia do material em texto

1
Aula 5
Professores:
Dante Corbucci Filho
Alexandre Plastino
Conteúdo:
 - Procedimentos
 - Funções
 - Passagem de Parâmetros
 - Recursividade
 
2
Subprogramação: Procedimentos e Funções
A utilização de procedimentos e funções permite que:
• Diferentes partes do programa possam ser desenvolvidas 
 e testadas separadamente;
• Partes do código possam ser reutilizadas em diferentes 
 pontos do programa;
• Programas complexos possam ser montados a partir de
 unidades menores já desenvolvidas e testadas.
3
Procedimento:
• Trata-se de um grupo de sentenças ao qual é 
 atribuído um nome. 
• Sua ativação se dá através deste nome. 
• A execução de um procedimento ocorre como 
 se o grupo de sentenças fosse copiado para 
 o ponto onde foi ativado.
Função:
• Trata-se de um grupo de sentenças ao qual é 
 atribuído um nome, que após a sua execução 
 retorna um valor (comportando-se como uma variável). 
• Sua ativação se dá através de expressões.
4
Procedimento
 O seguinte trecho de programa calcula o produto das 
variáveis X e Y, armazenando o resultado em Z.
 Este trecho pode ser transformado em um procedimento se 
for necessário ativá-lo mais de uma vez em diferentes pontos.
begin
 Z:= 0;
 for U:= 1 to X do
 Z:= Z + Y;
end;
5
program TestaMult(input{teclado}, output{vídeo});
var 
 X, Y, Z: integer;
 procedure Mult;
 var U: integer;
 begin {Início do procedimento Mult}
 Z:= 0;
 for U:= 1 to X do 
 Z:= Z+Y;
 end; {Fim do procedimento Mult}
begin
 X:= 20; Y:= 200;
 Mult;
 {Neste ponto, Z vale 4000.}
 X:= 15; Y:= 10;
 Mult;
 {Neste ponto, Z vale 150.}
end.
Nas ocorrências do nome Mult, 
a execução do programa 
principal é desviada ao 
procedimento Mult, retornando 
após o fim da execução do 
procedimento.
6
Função
• O procedimento Mult será transformado 
em uma função que retorna o resultado da 
multiplicação das variáveis X e Y.
• A palavra Mult representará, além da 
ativação da função, o valor retornado.
7
 program TestaMult(input{teclado}, output{vídeo});
 var 
 X, Y, W: integer;
 function Mult: integer;
 var Z, U: integer;
 begin {Início da função Mult}
 Z:= 0;
 for U:= 1 to X do Z:= Z+Y;
 Mult:= Z
 end; {Fim da função Mult}
 begin
 X:= 20; Y:= 200;
 W:= Mult + 10;
 {Neste ponto, W vale 4010}
 end.
A função Mult é ativada nesta 
atribuição e retorna o valor 
4000
8
Procedimento
Forma geral de definição de um procedimento (Aula 03):
procedure <nome_proc> [(<lista de parâmetros>)]
 [<declarações locais>]
 begin
 <corpo do procedimento>
 end;
 A ativação do procedimento se dará através da ocorrência 
de seu <nome_proc> como uma instrução no corpo do programa
principal (ou de algum outro procedimento ou função).
9
Função
Forma geral de definição de uma função (Aula 03):
function <nome_fun> [(<lista de parâmetros>)]: <tipo>;
 [<declarações locais>]
 begin
 <corpo da função>
 end;
 Dentro do corpo da função deverá haver pelo menos 
uma ocorrência da atribuição a seguir, que definirá o valor 
retornado pela função.
 <nome_fun>:= <expressão>
10
Função
 Toda função deve ser declarada como sendo de um <tipo>
simples: char, integer, real, boolean, enumerado, subintervalo, string
ou ponteiro (a ser visto).
 Quando for necessário o retorno um valor estruturado como
arrays ou records, deverá ser feito via um parâmetro ou via um 
ponteiro para o valor desejado (conceitos a serem vistos).
 A ativação de uma função se dará através da ocorrência de 
seu <nome_fun> em uma expressão definida no corpo do programa
principal (ou de algum outro procedimento ou função).
11
Passagem de Parâmetros
 Caso o procedimento (ou função) deva 
ser aplicado a diferentes operandos, ou seja, a 
diferentes valores de entrada, a definição deste 
procedimento (ou função) deve conter parâmetros.
12
 program TestaMult(input{teclado}, output{vídeo});
 function Mult(X,Y{e}: integer): integer;
 var Z, U: integer;
 begin {Início da função Mult}
 Z:= 0;
 For U:= 1 to X do Z:= Z+Y;
 Mult:= Z
 end; {Fim da função Mult}
 
 var W: integer;
 begin
 W:= Mult(20,200) + 10;
 {Neste ponto, W vale 4010}
 W:= Mult(10,100) + 20;
 {Neste ponto, W vale 1020}
 end.
Observe que as variáveis X e Y, 
que antes eram variáveis 
globais, agora são parâmetros
da função Mult e só são 
utilizadas dentro desta.
Na primeira ativação da função Mult, os 
parâmetros X e Y recebem os valores 20 e 200
Na segunda ativação da função Mult, os 
parâmetros X e Y recebem os valores 10 e 100
13
Tipos de Parâmetros em Pascal
Passagem de parâmetro por valor.
 
 Foi o caso tratado até o momento.
 No início do procedimento/função, os parâmetros 
são inicializados com os valores passados na ativação do 
procedimento/função.
 Esses valores podem ser: uma constante, o valor 
de uma variável, o resultado de uma expressão e até o 
resultado de uma função.
 Observe estas diferentes ativações da função Mult:
 W:= Mult(20, 200) + 10;
 W:= Mult(A,B) + 10;
 W:= Mult(A+B, Mult(C,D));
14
Tipos de Parâmetros em Pascal
Passagem de parâmetro por referência (por variável).
 
 Neste caso, a declaração do parâmetro é precedida
da palavra reservada var.
 procedure A(X{e}: char; var Y{s}: integer);
 
 Apenas variáveis podem ser passadas como parâmetro,
pois o conteúdo desta variável poderá ser alterado dentro do 
procedimento/função ativado.
 A(10+20, Z);
Por ReferênciaPor Valor
Ativação do procedimento A
15
 program TestaParRef(input{teclado}, output{vídeo});
 
 procedure ProximoPar(var N{e/s}: integer);
 begin
 if (N mod 2) = 0 then N:= N + 2
 else N:= N + 1
 end; 
 var X: integer;
 begin
 X:= 6;
 ProximoPar(X);
 {Neste ponto, X vale 8.}
 X:= X + 5;
 {Neste ponto, X vale 13.}
 ProximoPar(X);
 {Neste ponto, X vale 14.}
 end.
Passagem de parâmetro por referência (por variável).
- A passagem de parâmetro 
por referência ocorre como 
se o nome do argumento (no 
caso, a variável X) 
substituísse o parâmetro 
dentro do escopo do 
procedimento/função (no
caso, o parâmetro N).
 - Representa uma forma de 
se ter valores de saída de 
um procedimento/função.
16
Escopo de um Identificador em Pascal
 Todos os tipos de declarações utilizados no programa 
principal (const, type e var) podem também ser utilizados dentro 
de procedimentos (funções).
 Neste último caso, essas declarações definem objetos 
que são locais a este procedimento (função).
 Estes identificadores, assim como os parâmetros, não 
podem ser utilizados fora do respectivo procedimento (função). 
Ou seja, são locais ao procedimento (função).
 
17
Escopo de um Identificador em Pascal
 A região de validade de um identificador é chamada 
escopo do identificador. Em Pascal, o escopo de um 
identificador é o procedimento (função) no qual foi definido.
 Um identificador definido no programa principal é 
chamado de global e seu escopo é todo o programa 
(inclusive dentro dos procedimentos e funções).
 Um identificador definido dentro de um procedimento 
(função) P é considerado local a P e seu escopo é o código 
de P, incluindo o código de outros procedimentos e funções 
definidosdentro de P.
18
Escopo de um Identificador em Pascal
program Teste(input{teclado}, output{vídeo});
 var X: integer;
 procedure P(N{e}: integer);
 var Y: integer;
 begin
 {Neste ponto, X, Y e N são conhecidos}
 end; 
 procedure Q(M{e}: integer);
 var Z: integer;
 begin
 {Neste ponto, X, Z e M são conhecidos}
 end; 
begin
 {Neste ponto, apenas X é conhecido}
end.
19
Escopo de um Identificador em Pascal
program Teste(input{teclado}, output{vídeo});
var X: integer;
 
procedure Q(M{e}: integer);
var X,Z: integer;
begin
 {Neste ponto, a variável X local a Q, 
 Z e M são conhecidos.}
 X:= X + 1; 
 {A variável local X foi alterada.}
end; 
begin
 {Neste ponto, apenas X é conhecido.}
end.
Variável global X
 Variável local X
No caso de 
existirem dois 
identificadores, 
definidos em 
escopos diferentes, 
com o mesmo 
nome N, a 
ocorrência do nome 
N estará 
referenciando 
aquele com o 
escopo mais local.
20
Escopo de um Identificador em Pascal
program Local(input{teclado}, output{vídeo});
 
procedure Calc(X,Y{e}: integer; var W{s}: integer);
 function Cubo(Z{e}: integer): integer;
 begin {Início da função Cubo}
 Cubo:= Z * Z * Z
 end; {Fim da função Cubo}
 begin {Início do procedimento Calc}
 W:= Cubo(X) - Y
 end; {Fim do procedimento Calc} 
var X: integer;
begin {Início do programa principal}
 Calc(10,20,X)
 {Neste ponto, X vale (10*10*10)-20.}
end. {Fim do programa principal}
21
Ativação de Procedimentos/Funções
 Quando um procedimento/função é chamado, duas 
tarefas são executadas:
 (a) criação de um espaço de memória para as 
 variáveis locais e parâmetros e
 (b) passagem efetiva de parâmetros.
22
Ativação de Procedimentos/Funções
 Durante a execução de um programa Pascal, uma área 
especial de memória, organizada em forma de pilha ("stack"), 
é utilizada para armazenar os valores das variáveis locais e 
parâmetros dos procedimentos/funções e das variáveis globais do 
programa principal.
• Quando o programa principal é iniciado, a pilha contém um 
 espaço para as variáveis globais,
• Sempre que um procedimento/função é ativado, um espaço 
 contendo os valores das variáveis locais e parâmetros é
 reservado no topo da pilha,
• Ao fim de um procedimento/função, seu espaço é 
 automaticamente eliminado do topo da pilha.
23
Ativação de Procedimentos/Funções
 program P(input{teclado}, output{vídeo});
 var X,Y,Z: integer;
 
 procedure Soma(A,B{e}: integer; var C{s}: integer);
 begin 
 C:= A + B
 end; 
 begin 
 X:= 2;
 Y:= 3;
 Soma(X,Y,Z);
 writeln(output, Z);
 
 end. 
24
Ativação de Procedimentos/Funções
 program P(input{teclado}, output{vídeo});
 var X,Y,Z: integer;
 
 procedure Soma(A,B{e}: integer; var C{s}: integer);
 begin 
 C:= A + B
 end; 
 begin 
 X:= 2;
 Y:= 3;
 Soma(X,Y,Z);
 writeln(output, Z);
 
 end. X Y Z
Área do 
programa 
principal
Pilha de
Memória
25
Ativação de Procedimentos/Funções
 program P(input{teclado}, output{vídeo});
 var X,Y,Z: integer;
 
 procedure Soma(A,B{e}: integer; var C{s}: integer);
 begin 
 C:= A + B
 end; 
 begin 
 X:= 2;
 Y:= 3;
 Soma(X,Y,Z);
 writeln(output, Z);
 
 end. X Y Z
Área do 
programa 
principal
Pilha de
Memória
2
26
Ativação de Procedimentos/Funções
 program P(input{teclado}, output{vídeo});
 var X,Y,Z: integer;
 
 procedure Soma(A,B{e}: integer; var C{s}: integer);
 begin 
 C:= A + B
 end; 
 begin 
 X:= 2;
 Y:= 3;
 Soma(X,Y,Z);
 writeln(output, Z);
 
 end. X Y Z
Área do 
programa 
principal
Pilha de
Memória
2 3
27
Ativação de Procedimentos/Funções
 program P(input{teclado}, output{vídeo});
 var X,Y,Z: integer;
 
 procedure Soma(A,B{e}: integer; var C{s}: integer);
 begin 
 C:= A + B
 end; 
 begin 
 X:= 2;
 Y:= 3;
 Soma(X,Y,Z);
 writeln(output, Z);
 
 end. X Y Z
2 3
A B C
2 3
Área do 
programa 
principal
Área do 
procedimento
Soma
Pilha de
Memória
28
Ativação de Procedimentos/Funções
 program P(input{teclado}, output{vídeo});
 var X,Y,Z: integer;
 
 procedure Soma(A,B{e}: integer; var C{s}: integer);
 begin 
 C:= A + B
 end; 
 begin 
 X:= 2;
 Y:= 3;
 Soma(X,Y,Z);
 writeln(output, Z);
 
 end. 
Área do 
programa 
principal
Pilha de
Memória
X Y Z
2 3 5
29
Recursividade
 Um procedimento (ou função) é chamado recursivo 
quando possui no seu corpo uma chamada a ele próprio.
 Um exemplo comum de utilização de recursividade
é o cálculo da função fatorial de um número natural.
 1 , se n = 0; {caso base} 
 n! = 
 n * (n-1)! , se n > 0. {expressão de recorrência} 
 3! = 3*2! = 3*2*1! = 3*2*1*0! = 3*2*1*1 = 6
30
Recursividade
 1 , se n = 0; {caso base} 
 n! = 
 n * (n-1)! , se n > 0. {expressão de recorrência} 
function Fat(N{e}: integer): integer;
begin
 if N = 0 then Fat:= 1 {condição de parada} 
 else Fat:= N*Fat(N-1) {chamada recursiva} 
end; 
31
Recursividade
 program Rec(input{teclado}, output{vídeo});
 function Fat(N{e}: integer): integer;
 begin
 if N = 0 then Fat:= 1
 else Fat:= N * Fat(N-1) 
 end;
 
 var X: integer;
 begin 
 X:= Fat(3); 
 end. 
Área do 
programa 
principalX
32
Recursividade
 program Rec(input{teclado}, output{vídeo});
 function Fat(N{e}: integer): integer;
 begin
 if N = 0 then Fat:= 1
 else Fat:= N * Fat(N-1) 
 end;
 
 var X: integer;
 begin 
 X:= Fat(3); 
 end. 
Área do 
programa 
principal
Fat(3)
X
Fat N
3
33
Recursividade
 program Rec(input{teclado}, output{vídeo});
 function Fat(N{e}: integer): integer;
 begin
 if N = 0 then Fat:= 1
 else Fat:= N * Fat(N-1) 
 end;
 
 var X: integer;
 begin 
 X:= Fat(3); 
 end. 
Área do 
programa 
principal
Fat(3)
Fat(2)
X
Fat N
3
Fat N
2
34
Recursividade
 program Rec(input{teclado}, output{vídeo});
 function Fat(N{e}: integer): integer;
 begin
 if N = 0 then Fat:= 1
 else Fat:= N * Fat(N-1) 
 end;
 
 var X: integer;
 begin 
 X:= Fat(3); 
 end. 
Área do 
programa 
principal
Fat(3)
Fat(2)
Fat(1)
X
Fat N
3
Fat N
2
Fat N
1
35
Recursividade
 program Rec(input{teclado}, output{vídeo});
 function Fat(N{e}: integer): integer;
 begin
 if N = 0 then Fat:= 1
 else Fat:= N * Fat(N-1) 
 end;
 
 var X: integer;
 begin 
 X:= Fat(3); 
 end. 
Área do 
programa 
principal
Fat(3)
Fat(2)
Fat(1)
Fat(0)
X
Fat N
3
Fat N
2
Fat N
1
Fat N
0
36
Recursividade
 programRec(input{teclado}, output{vídeo});
 function Fat(N{e}: integer): integer;
 begin
 if N = 0 then Fat:= 1
 else Fat:= N * Fat(N-1) 
 end;
 
 var X: integer;
 begin 
 X:= Fat(3); 
 end. 
Área do 
programa 
principal
Fat(3)
Fat(2)
Fat(1)
Fat(0)
X
Fat N
3
Fat N
2
Fat N
1
Fat N
01
37
Recursividade
 program Rec(input{teclado}, output{vídeo});
 function Fat(N{e}: integer): integer;
 begin
 if N = 0 then Fat:= 1
 else Fat:= N * Fat(N-1) 
 end;
 
 var X: integer;
 begin 
 X:= Fat(3); 
 end. 
Área do 
programa 
principal
Fat(3)
Fat(2)
Fat(1)
X
Fat N
3
Fat N
2
Fat N
11
38
Recursividade
 program Rec(input{teclado}, output{vídeo});
 function Fat(N{e}: integer): integer;
 begin
 if N = 0 then Fat:= 1
 else Fat:= N * Fat(N-1) 
 end;
 
 var X: integer;
 begin 
 X:= Fat(3); 
 end. 
Área do 
programa 
principal
Fat(3)
Fat(2)
X
Fat N
3
Fat N
22
39
Recursividade
 program Rec(input{teclado}, output{vídeo});
 function Fat(N{e}: integer): integer;
 begin
 if N = 0 then Fat:= 1
 else Fat:= N * Fat(N-1) 
 end;
 
 var X: integer;
 begin 
 X:= Fat(3); 
 end. 
Área do 
programa 
principal
Fat(3)
X
Fat N
36
40
Recursividade
 program Rec(input{teclado}, output{vídeo});
 function Fat(N{e}: integer): integer;
 begin
 if N = 0 then Fat:= 1
 else Fat:= N * Fat(N-1) 
 end;
 
 var X: integer;
 begin 
 X:= Fat(3); 
 end. 
Área do 
programa 
principalX
6
41
Recursividade
 Trata-se também de uma forma de repetição de um
determinado trecho de código.
 Apesar de nenhum comando explícito de repetição ter 
sido utilizado, na prática o código anterior executa um produto 
de N termos.
 A função fatorial poderia também ser definida por:
 1 , se n = 0;
n! = 
 1 * 2 * ... * n , se n > 0.
42
Implementação Iterativa para fatorial
 1 , se n = 0;
n! = 
 1 * 2 * ... * n , se n > 0.
 function Fat(N{e}: integer): integer;
 var 
 P,Ind: integer;
 begin
 P:= 1; 
 for Ind:= 1 to N do
 P:= P * Ind;
 Fat:= P
 end. 
43
Funções e Procedimentos como Parâmetros
program ParFunc(input{teclado}, output{vídeo});
 type T_Funcao = function(X{e}: integer): integer;
 function Soma(F{e}: T_Funcao; N{e}: integer): integer;
 var Aux, Ind: integer;
 begin {Esta função soma os n primeiros valores de uma dada função F}
 Aux:= 0;
 for Ind:= 1 to N do Aux:= Aux + F(Ind);
 Soma:= Aux
 end;
 function Fatorial(Num{e}: integer): integer;
 begin 
 if Num=0 then Fatorial:= 1 else Fatorial:= Num*Fatorial(Num-1);
 end;
 function Fib(Num{e}: integer): integer;
 begin 
 if (Num=1) or (Num=2) then Fib:= 1 else Fib:= Fib(Num-1)+Fib(Num-2);
 end;
var Total: integer;
begin
 Total:= Soma(Fatorial,10) + Soma(Fib,10)
end.
44
A Declaração "Forward"
 Em alguns casos, pode ser necessário que dois subprogramas 
se chamem reciprocamente (recursividade mútua).
 Procedure Flip(N{e}: Integer); forward;
 Procedure Flop(N{e}: Integer);
 begin
 writeln(output, ’Flop’);
 if N > 0 then Flip(N - 1);
 end;
 Procedure Flip; {Agora, sem a declaração dos parâmetros.} 
 begin
 writeln(output, ’Flip’);
 if N > 0 then Flop(N - 1);
 end;
45
Aula 5
Professores:
Dante Corbucci Filho
Alexandre Plastino
Conteúdo:
 - Procedimentos
 - Funções
 - Passagem de Parâmetros
 - Recursividade