Você está na página 1de 17

5.

PROCEDIMENTOS E FUNÇÕES
Até .....

5.1 Procedimentos Simples

Procedimentos são rotinas (trechos ou módulos) de programas, capazes de executar
uma tarefa definida pelo programador. Os programas desenvolvidos com procedimentos
são ditos ‘modulares’. Os programas desenvolvidos com procedimentos são mais legíveis e
melhor estruturados.

Todo procedimento deverá ter um nome e um corpo (conjunto de instruções) e
deverá ser escrito no campo de declaração de variáveis, imediatamente abaixo destas. Sua
sintaxe pode ser vista abaixo:

Procedure <nome_do_procedimento> ;
<declaração_de_variáveis_locais> ;
Begin
<comandos> ;
End;

Todo procedimento possui um espaço para declaração de variáveis, chamadas de
variáveis locais, embora não seja obrigatório o seu uso. As variáveis declaradas no
programa principal são chamadas de variáveis globais.

Dentro do procedimento podem ser utilizadas tanto variáveis locais quanto variáveis
globais. Todas as variáveis locais aos procedimentos são alocadas somente quando o
procedimento entra em execução, mas são liberadas quando o procedimento termina,
perdendo assim, seus conteúdos. Caso seja necessário o aproveitamento dos dados
manipulados, o procedimento deverá utilizar as variáveis globais.

Para executar o procedimento (comandos), o mesmo deverá ser acionado pelo
nome. Para exemplificarmos, vamos imaginar um procedimento chamado Cálculo, que
serve para calcular uma operação matemática qualquer sobre as variáveis X e Y. Então,
poderíamos ter o seguinte trecho do programa:
:
Read( X );
Read( Y );
Cálculo ;
Write(Resultado);
:
No exemplo acima, após a leitura da variável Y, deverá ser executado o corpo do
procedimento Cálculo. Após a execução deste procedimento será executado o comando
escreve o restante do programa.

Escopo da Variável

Neste caso P2 é global a P1. Y. e dentro destes outros procedimentos. N Procedimento B variáveis K. No exemplo acima temos: . W Procedimento D variáveis M. interno e adjacente. P2 é interno a P1. W Procedimento F variáveis M. .No exemplo acima temos: . da seguinte forma: 1) Um procedimento P1 é dito global a um procedimento P2. e assim por diante. Y.A é global a D e E . .D e E são internos a A . .W Procedimento E variáveis K. Neste caso. X. poderão também ser definidos outros procedimentos internos. podemos definir basicamente 3 tipos de relação entre procedimentos: global. se P1 está dentro de P2. ou vice-versa. M. Z Em função do exemplo acima.B é global a F 2) Um procedimento P1 é dito interno a um procedimento P2. P. X. Q Procedimento C variáveis X. se P2 está dentro de P1.F é interno a B 3) Dois procedimento P1 e P2 são adjacentes. Assim. No campo de declaração de variáveis locais ao procedimento. N . poderemos ter um programa com vários procedimentos. se P1 não é interno e nem global a P2. conforme mostra o exemplo da figura abaixo: Algoritmo Principal variáveis X. Z Procedimento A variáveis K.

End. End. IMPORTANTE!!! Cada procedimento poderá utilizar suas próprias variáveis ou as variáveis mais globais a ele. . e consequentemente. Var a.D.c).4*a*c) . End. x2).A. Begin x1 := (-b+SQRT(delta))/(2*a) . Begin delta := (b*b . End. b. F e C são adjacentes 4) O programa principal é global a todos os procedimentos. Calcula_Delta . End. Procedure Leia_Coeficientes .b. B e C são adjacentes. delta. . E. Procedure Calcula_Raízes . O nível mais global em que uma variável possa ser utilizada é chamado ‘escopo da Variável’. Until (a <> 0) . Program Calcula -Raizes . x1. todos os procedimentos são internos ao programa principal. x2 : Real . Procedure Calcula_Delta . Write(x1. Exemplo: Faça um programa que calcule as raízes de uma equação do 2° grau. Begin Leia_Coeficientes . Funções Simples . If delta < 0 Then Write(‘Não existem raizes reais’) Else Begin Calcula_Raizes . c. Begin Repeat Read(a. mas nunca uma variável de um outro procedimento adjacente. x2 := (-b-SQRT(delta))/(2*a) . usando procedimentos.

Program Soma_Vetores. Funções são rotinas similares aos procedimentos. Var I: Integer . End.10] of Integer . Begin <lista-de-comandos> . v: Array[1. Var i : Integer . Exemplo 1: Faça um programa que leia continuamente vários vetores.. e sua sintaxe é mostrada abaixo. Function Soma : Real. este deverá ser explicitamente atribuído ao nome da função. mas deverá ser atribuída à alguma Var. Uma função não deverá simplesmente ser chamada. como no caso dos procedimentos. Leitura_do_Vetor. A leitura dos vetores deverá ser finalizada quando a soma do último for zero (0). <declaração_de_variáveis_locais> . O nome da função é quem deve assumir o valor da função. Function <nome_da_função> : <tipo> . e calcule para cada um a soma de seus elementos. (* aqui é atribuído o valor de retorno *) End. Para que a função possa retornar um valor. Assim como nos procedimentos. For i := 1 To N Do S := S + v[i]. Soma := S. S: Real. s : Real. Procedure Leitura_do_Vetor. de tamanhos variados. . dentro da rotina da função. Begin For i := 1 To n Do Read( v[i]). utilizando função. Begin S := 0. End. Var n: Integer. só que retornam um valor após cada chamada. como se fosse uma variável. uma função deve ser definida dentro do espaço de declaração de variáveis do programa. Uma função deve ter um nome e um tipo. Begin Repeat Read(n).

Eliminação. A solução básica está a seguir. Write(‘3 . (* no máximo 3000 exemplares *) Type tipo_ficha = Record código: Integer . . Write(‘4 . (* indica que o Record está disponível *) End. 3: Biológicas *) End . Var fichario : tipo_fichario .código := -1 . Consulta e Listagem de livros. Procedure Inicializa_Variáveis. O programa deverá permitir as seguintes operações: Inserção. (* 1: Humanas . Write(‘Soma = ‘. For i := 1 To n Do fichario [i].n] of tipo_ficha . End.Sair’).Atualizar Cadastro’). s := Soma .Consultar Livros Cadastrados’). Program Gerencia_Biblioteca . tamanho. área: Integer . Write(‘2 .. Until s = 0. Begin tamanho := 0 . Repeat Read( opção ). Trabalho Individual: Faça um programa em Pascal para o gerenciamento de uma biblioteca utilizando um vetor. Write(‘6 .Listar Acervo’). Procedure Apresenta_Menu. tipo_fichario: Array[1. Var i : Integer. Write(‘5 . opção. s). Begin Write(‘1 . Until (opção > 0) and (opção < 7) . Alteração. 2: Exatas . código : Integer . Const n = 3000 . autor: String [30] .Inserir Novo Cadastro’).Eliminar Cadastro Velho’). título: String [20] .

Var achou. . Var Function Cheia: Boolean . Function Busca: Integer . While (fichario[i]. Begin achou := False . Var i : Integer . autor. acabou: Boolean . End Else Write(‘Fichario Lotado’) . With fichario[pos] Do Begin Read(código.End .area). Function Posição_Livre: Integer. End . Write(‘Cadastro Inserido’). acabou := False . Begin Cheia := (tamanho = n) . i : Integer . End. Procedure Insere. i := 0 . pos := Posição_Livre . Begin i := 1 . End. Begin If Not Cheia Then Begin Inc(tamanho). End . título .código <> -1) i := i + 1 . Posição_Livre := i . While (Not achou) And (Not acabou) Do Begin i := i + 1 .

area). Begin Read(código).código = código) . pos := busca . If (pos = -1) Then Write(‘Cadastro Inexistente’) Else With fichario[pos] Do Write(código. Var pos : Integer . Var pos : Integer . Procedure Altera. If (pos = -1) Then Write(‘Cadastro Inexistente’) Else Begin fichario[pos]. End. If (pos = -1) Then Write(‘Cadastro Inexistente’) Else Begin With fichario[pos] Do Read(código. Procedure Elimina. área). End.código := -1 . Var pos : Integer . pos := busca . End. autor. Write(‘Cadastro Eliminado’). título . acabou := (i = n) . Begin Read(código). End . . End. Procedure Consulta. Begin Read(código). pos := busca . tamanho := tamanho -1 . If achou Then Busca := i Else Busca := -1 . título. Write(‘Cadastro Alterado’). End . autor. achou := (fichario[i].

end. chamado parâmetro. título. pos := 1. While (pos <= tamanho) Do Begin If (fichario[pos]. Precisamos em cada momento que ela nos retorne a ra iz quadrada para um valor diferente. t := t + 1. . end . End . Os parâmetros devem ser em igual quantidade e de mesmos tipos. end. os procedimentos e as funções eram executadas sem que nenhum dado fosse passado específicamente para eles. 5: Lista . Repeat Apresenta_Menu . Case opção of 1: Insere . Imaginemos uma função que calcula a raiz quadrada de um número (SQR). 2: Elimina . Procedures e Funções com Passagem de Parâmetros Até agora. Begin t := 0. como por exemplo: SQRT(9) ou SQRT(x) Para chamarmos uma função ou procedimento deste tipo. Procedure Lista. until opção = 6 . autor. 3: Altera .código <> -1) Then Begin With fichario[pos] Do Write(código. End. a não ser as variáveis globais. pos := pos + 1 . Muitas vezes precisamos executar um procedimento e/ou função sobre conjuntos de dados diferentes. área) . conforme foi definida a função ou o procedimento. Begin Inicializa_Variáveis . pos : Integer . Assim. devemos colocar o nome seguido de um conjunto de parâmetros entre parênteses. passamos para ela um valor. 4: Consulta . Var t.

As variáveis declaradas se comportam como se fossem as próprias variáveis de chamada. end. todas as modificações realizadas nos parâmetros dentro do corpo da função ou do procedimento serão repassados para as variáveis passadas durante a chamada. Devemos salientar que as variáveis declarados no procedimento ou na função são chamadas ‘parâmetros declarados’. s2.c).c : Real) . É como se o procedimento ou função estivessem usando as próprias variáveis que foram passadas como parâmetros. poderíamos ter o seguinte trecho de programa: : Leitura (m.b. s3 ).p) . e que as variáveis passadas durante a chamada são chamadas ‘parâmetros de chamada’. Ex: Seja os seguintes procedimento e função: Procedure Leitura (a. conforme exemplos da declaração abaixo: Procedure Leitura (a.n.p) .b.p) .b.n) . devemos escrever algo do tipo: Leitura (x1.c : Real) . s3 := Soma (m. ou Function Soma ( x. x3) . Function Soma ( x. Begin Read( a. quando se usar passagem por referência. ou s := Soma (f. Begin Soma := x + y . y : Real): Real . Existem 2 (dois) tipos de passagem de parâmetros: por referência ou por valor: Passagem por Referência : Os parâmetros devem ser declarados dentro de parênteses. Não existe a necessidade dos nomes dos parâmetros declarados serem iguais aos parâmetros de chamada. Neste caso. s1 := Soma (m. Para chamarmos o procedimento e a função acima. . x2. IMPORTANTE!!! Tudo o que for feito com os parâmetros declarados será feito com os parâmetros de chamada. Write(s1.y : Real): Real . s2 := Soma (n. end. g) .

N2 e N3 respectivamente. concluímos que as formas corretas para declarar estes procedimentos seriam: Procedure Leitura (a.b.b. IMPORTANTE!!! Podemos utilizar nos procedimentos e nas funções. pois eles não eram de fatos alterados. tam_A.c : Real) . poderemos facilmente concluir que a função ‘Soma’ realmente não necessitava de parâmetros por referência. Utilizando o mesmo exemplo anterior. uma mistura de parâmetros por rererência e por valor. Var x. Este tipo de passagem de parâmetros deve ser utilizado quando só interessa o valor do dado para o procedimento ou para a função. R: Array[1. Assim. e Function Soma ( x. Exemplo : Faça um programa que leia 3 vetores numéricos A.c) . Var a.. teríamos a seguinte declaração: Procedure Leitura (a. ordenados e de tamanhos N1. tam : Integer ). tam_R : Integer .y : Real .n] of Integer .y): Real . B. Mas podemos também perceber que o procedimento ‘Leitura’ deve necessariamente utilizar parâmetros por referência.c : Real .. Procedure Leia_Vetor( V: tipo_vetor . B e C. Var x. m = 300 . Neste caso. A chamada dos procedimentos e das funções é feita da mesma forma que da passagem por referência. Analisando este exemplos. tam_B. e dentro do espaço de declaração de variáveis locais. : Passagem por Valor: Os parâmetros devem ser declarados fora do parênteses.y): Real . tam_C.m] of Integer.y : Real . C: tipo_vetor . ou Function Soma ( x. Program Concatena_Vetores. . Var A. Const n = 100 . e junte-os em um único vetor resultante R ordenado de tamanho N1+N2+N3. pois senão os dados lidos serão perdidos após o término do procedimento. as alterações sofridas pelas variáveis declaradas não serão repa ssadas para as variáveis de chamada. de acordo com as necessidades do programa.b. Type tipo_vetor: Array[1.

Repeat If (A[iA] < B[iB]) and (A[iA] < C[iC]) Then Atribui(A. i. iB.j.iR) . Procedure Descarrega_Final(A: tipo_vetor .i. B. i := i + 1 . Begin R[j] := V[i] .j: Integer ). iB := 1 . Begin iA := 1 . iC. For i := 1 To tam Do Read( V[i] ). Var iA. End.j) .Var i : Integer . i. Begin Read( tam ). Procedure Descarrega_Segundo(A. Procedure Atribui (V: tipo_vetor.iB.j: Integer ).B:tipo_vetor . iC := 1 . tam_R := tam_A + tam_B + tam_C . until (j > tam_R) . Procedure Concatena(A.k) Else Atribui(B. End. tam_C: Integer ). Begin If (A[i] < B[j]) Then Atribui(A. tam_A.iA. End. Begin Repeat Atribui(A.i.k). iR : Integer .k: Integer ). End. j := j + 1 . C:tipo_vetor. i.iR) Else If (B[iB] < A[iA]) and (B[iB] < C[iC]) Then Atribui(B. iR := 1 .j. tam_B.

iR). end.B. C. tam_B. onde os 3 primeiros são por valor e os 2 últimos são por referência. B. 3) Supondo que você tenha uma tabela (vetor de registros).iC. Else Atribui(C.iB. 2° TRABALHO INDIVIDUAL 1) Faça um mapa de memória para a declaração abaixo. retornando os resultados no quarto e quinto parâmetros respectivamente. supondo que a memória disponível inicie na posição 1000..iA. Var A: Real . B: Array[1.iR) Else If (iB > tam_B) Then Descarrega_Segundo(A. End . definida da forma abaixo: Const n = 1000. Concatena(A.iB. End . código: Integer . tam_C) .10] of Lógico . tam_A. Type tipo_reg = Record nome: String [15] . Leia_Vetor (B. tam_A) .iA.iC. 2) Faça um procedimento que tenha 5 parâmetros.iC. Este procedimento deverá calcular a soma e o produto dos 3 primeiros parâmetros. tam_B) .iA. If (iA > tam_A) Then Descarrega_Segundo(B. End . tam_C) . Indique neste mapa as posições inicial e final para cada Var. Leia_Vetor (C.iR) Else If (iB ≤ tam_B) Then Descarrega_Final(B. Until (iA > tam_A) or (iB > tam_B) or (iC > tam_C) .iR) Else Descarrega_Segundo(A. Begin Leia_Vetor (A.iR) Else Descarrega_Final(C.C.iC.C. If (iA ≤ tam_A) Then Descarrega_Final(A. N : String [5] . Ficha: Record placa: String [7] .iR). salário: Real .iB.iR). .

Onde a tabela deve ser organizada da seguinte maneira: a) A inserção de um novo registro deve ser sempre após o último elemento válido. fim). : : procedure Escreva(início. . Obs: Implemente as funções Cheia e Vazia e as utilize. begin : : if x> 0 then Calcula(y). Implemente: 1) Uma função de inserção. deve-se colocar o último registro válido do lugar do elemento eliminado e atualizar o registro flag para o registro que foi transferido. tal como os exemplos a seguir: Exemplo Genérico: procedure Calcula(x: integer). : : end. contendo um salário negativo (‘marca de final de tabela’) c) Para se eliminar um registro. RECURSIVIDADE A recursividade ocorre quando dentro de um procedimento (ou função) existe uma chamada (direta ou indireta) para o mesmo procedimento (ou função). var y: real.. begin write(início). var N : integer. fim :integer). que tenha como parâmetro o elemento a ser inserido. b) Para controlar qual registro é o último registro válido. 2) Uma função de remoção. A função deverá retornar True ou False conforme o sucesso ou não da operação. Exemplo Prático: Escreve os números compreendidos entre 1 até N recursivamente. deve ser inserido após o último registro um registro flag. program Escrever. o procedimento “escreva” é recursivo e serve para escrever de “início” até “fim”. Var tabela: Array[1. Neste exemplo.n] of tipo_reg . que tenha como parâmetro o elemento a ser removido. if início < fim then Escreva(início+1. A função deverá retornar True ou False conforme o sucesso ou não da operação.

SomaVetor(1. com algumas adaptações. : : begin : : read(N). mas cada instância conservam separadamente suas próprias variáveis locais. : : end. podemos implementar uma função para somar linhas de uma matriz. Usando a função anterior de somar vetores. end. Exemplo Prático: Somar os elementos de um vetor A recursivamente. As diversas chamadas recursivas ocorrem em instâncias diferentes. Escreva(1. end. fim).N)). as variáveis utilizadas em uma instância são diferentes daquelas utilizadas nas outras instâncias. : : procedimento SomaVetor(início.. : : end. Neste exemplo. write(‘Soma do Vetor = ‘. o procedimento “soma” é recursivo e serve para somar os elementos contidos entre as posições “início” e “fim” do vetor A. var . a função “SomaLinha” somará os elementos da linha “linha” compreendidos entre “início” e “N”.. fim :integer). begin if início = fim then SomaVetor := A[início] else SomaVetor:= A[início] + SomaVetor(início+1. Neste caso. program SomarElementosVetor. como se houvessem vários procedimentos (ou funções) iguais sendo chamados. ou seja.N). A recursividade pode ser aplicada para resolver problemas onde a solução no estado atual depende da solução do estado anterior. A . : : begin : : read(N).

e este por sua vez depende de (N-2)!. início+1). end. Sabemos que N! depende de (N-1)!. início :integer).1) else SomaMatriz := SomaLinha(L1. if L1 < L2 then soma := soma + SomaMatriz(L1+1. início] + SomaLinha(linha. coluna+1) : : SomaLinha := soma. L2: integer): real. var soma: real. begin if L1 = M /* última linha da matriz */ then SomaMatriz := SomaLinha(L1. coluna]. begin : : soma := SomaLinha(L1. coluna: integer): real. : : SomaMatriz := soma. begin if início = N /* último elemento da linha */ then SomaLinha := B[linha. Fatorial Como exemplo clássico temos o cálculo da fatorial. e assim por diante até que N seja 1. início] else SomaLinha:= B[linha. function SomaMatriz(L1. var soma: real.1). end. function SomaLinha(linha.função “SomaMatriz” utilizará a função “SomaLinha” para somar as linhas compreendidas entre “L1” e “M”. begin : : soma := M[linha. function SomaMatriz(L1: integer): real. quando então . end.1) + SomaMatriz(L1+1) end. L2). procedure SomaLinha(linha. if coluna < N then soma := soma + SomaLinha(linha. Supoe-se que a Matriz B tenha MxN elementos.

end.teremos que fatorial de 1 é igual a 1 mesmo. então para mudar o elemento da base antes será necessário mudar os (N-1) elementos que estão acima da base. representando a torre de origem (O). . Podemos utilizar números inteiros para representar os elementos empilhados.D. o maior elemento deverá estar sempre na base e o menor sempre no topo. A Torre de Hanoi compõe-se de uma pilha de elementos ordenados. var elem : integer. ColocaElem(Elem. a idéia é mover esta pilha para uma outra base B usando uma terceira base de apoio C. procedure Hanoi (var O. begin If N <= 1 then fatorial := 1 else fatorial := N * fatorial (N-1). pois um procedimento ou função não pode ficar chamando a si próprio indefinidamente. Devemos observar nos exemplos que existe uma condição de parada para a recursividade. 4 7 12 ___ A Bem. D). A solução pode ser vista na forma simplificada a seguir. Podemos implementar a solução usando 3 vetores O. D. D e A. Ele contém uma torre de Hanoi na base A.A. onde somente é permitido somente empilhar um elemento menor sobre um elemento maior. N: integer). Mas estes (N-1) elementos formam na verdade uma torre de Hanoi menor e para você mudá-la será necessário mudar os (N-2 elementos que estão acima da sua base e o raciocínio se repete recursivamente. Assim sendo. RetiraElemento(O.N-1). Veja o exemplo a seguir. A: tipo_torre. A solução da fatorial pode ser obtida a seguir: function fatorial (N : integer) : real. Os elementos devem ser empilhados e desempilhados um a um de forma que os elementos menores sejam colocados sobre os maiores. a torre auxiliar (A) e a torre destino (D). begin if N <> 0 then begin Hanoi(O. Torre de Hanoi Um outro exemplo clássico é o da Torre de Hanoi. A idéia geral da solução é que se existe uma torre de N elementos. Elem).

Max] of integer. end. .N-1).. type tipo_torre = record torre: array[1. end.D. End.O. T. end.quant]. var X: integer). var i : integer.quant] := X.A. A. procedure RetiraElemento(var T: tipo_torre.quant := 0.torre[T. end. que será transferida do vetor O para o vetor D usando o A como auxiliar. quant: integer. end. End.torre[T. var T: tipo_torre).i+1.quant). Hanoi(A.torre[i] := N. D. dec(T. Hanoi(O. O. Onde: const Max = 100. procedure InicializaTorres(N:integer). begin for i:= 1 to N do O. InicializaTorres(N). begin inc(T. procedure InsereElemento(X: integer.quant := N.N).D.quant). Seria interessante acrescentar no programa anterior trechos para a apresentação e visualização da torre.quant := 0. Programa Principal Begin Read(N). begin X := T.