Pascal - Procedimentos

Procedures são subprogramas que, ao invés de retornar um único valor, permitem obter um conjunto de resultados.

Definindo um Procedimento

Em Pascal, um procedimento é definido usando o procedurepalavra-chave. A forma geral de uma definição de procedimento é a seguinte -

procedure name(argument(s): type1, argument(s): type 2, ... );
   < local declarations >
begin
   < procedure body >
end;

Um procedimento definition em Pascal consiste em um header, local declarations e um bodydo procedimento. O cabeçalho do procedimento consiste na palavra-chaveproceduree um nome dado ao procedimento. Aqui estão todas as partes de um procedimento -

  • Arguments- O (s) argumento (s) estabelecem a ligação entre o programa de chamada e os identificadores do procedimento e também chamados de parâmetros formais. As regras para argumentos em procedimentos são iguais às das funções.

  • Local declarations - As declarações locais referem-se às declarações para rótulos, constantes, variáveis, funções e procedimentos, que são aplicáveis ​​apenas ao corpo do procedimento.

  • Procedure Body- O corpo do procedimento contém uma coleção de instruções que definem o que o procedimento faz. Deve sempre ser colocado entre as palavras reservadas início e fim. É a parte de um procedimento onde todos os cálculos são feitos.

A seguir está o código-fonte para um procedimento chamado findMin () . Este procedimento usa 4 parâmetros x, y, z e me armazena o mínimo entre as três primeiras variáveis ​​na variável chamada m. A variável m é passada porreference (discutiremos a passagem de argumentos por referência um pouco mais tarde) -

procedure findMin(x, y, z: integer; var m: integer); 
(* Finds the minimum of the 3 values *)

begin
   if x < y then
      m := x
   else
      m := y;
   
   if z <m then
      m := z;
end; { end of procedure findMin }

Declarações de procedimento

Um procedimento declarationinforma ao compilador sobre o nome de um procedimento e como chamá-lo. O corpo real do procedimento pode ser definido separadamente.

Uma declaração de procedimento tem a seguinte sintaxe -

procedure name(argument(s): type1, argument(s): type 2, ... );

Observe que o name of the procedure is not associated with any type. Para o procedimento acima definido findMin () , a seguir está a declaração -

procedure findMin(x, y, z: integer; var m: integer);

Chamando um Procedimento

Ao criar um procedimento, você dá uma definição do que o procedimento deve fazer. Para usar o procedimento, você terá que chamar aquele procedimento para executar a tarefa definida. Quando um programa chama um procedimento, o controle do programa é transferido para o procedimento chamado. Um procedimento chamado executa a tarefa definida e, quando sua última instrução final é alcançada, ele retorna o controle ao programa de chamada.

Para chamar um procedimento, você simplesmente precisa passar os parâmetros necessários junto com o nome do procedimento conforme mostrado abaixo -

program exProcedure;
var
   a, b, c,  min: integer;
procedure findMin(x, y, z: integer; var m: integer); 
(* Finds the minimum of the 3 values *)

begin
   if x < y then
      m:= x
   else
      m:= y;
   
   if z < m then
      m:= z;
end; { end of procedure findMin }  

begin
   writeln(' Enter three numbers: ');
   readln( a, b, c);
   findMin(a, b, c, min); (* Procedure call *)
   
   writeln(' Minimum: ', min);
end.

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

Enter three numbers:
89 45 67
Minimum: 45

Subprogramas recursivos

Vimos que um programa ou subprograma pode chamar outro subprograma. Quando um subprograma chama a si mesmo, é referido como uma chamada recursiva e o processo é conhecido como recursão.

Para ilustrar o conceito, vamos calcular o fatorial de um número. Fatorial de um número n é definido como -

n! = n*(n-1)!
   = n*(n-1)*(n-2)!
      ...
   = n*(n-1)*(n-2)*(n-3)... 1

O programa a seguir calcula o fatorial de um determinado número chamando a si mesmo recursivamente.

program exRecursion;
var
   num, f: integer;
function fact(x: integer): integer; (* calculates factorial of x - x! *)

begin
   if x=0 then
      fact := 1
   else
      fact := x * fact(x-1); (* recursive call *)
end; { end of function fact}

begin
   writeln(' Enter a number: ');
   readln(num);
   f := fact(num);
   
   writeln(' Factorial ', num, ' is: ' , f);
end.

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

Enter a number:
5
Factorial 5 is: 120

A seguir está outro exemplo, que gera o Fibonacci Series para um determinado número usando um recursive função -

program recursiveFibonacci;
var
   i: integer;
function fibonacci(n: integer): integer;

begin
   if n=1 then
      fibonacci := 0
   
   else if n=2 then
      fibonacci := 1
   
   else
      fibonacci := fibonacci(n-1) + fibonacci(n-2);
end; 

begin
   for i:= 1 to 10 do
   
   write(fibonacci (i), '  ');
end.

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

0 1 1 2	3 5 8 13 21 34

Argumentos de um Subprograma

Se um subprograma (function or procedure) é usar argumentos, ele deve declarar variáveis ​​que aceitam os valores dos argumentos. Essas variáveis ​​são chamadas deformal parameters do subprograma.

Os parâmetros formais se comportam como outras variáveis ​​locais dentro do subprograma e são criados na entrada no subprograma e destruídos na saída.

Ao chamar um subprograma, existem duas maneiras de os argumentos serem passados ​​para o subprograma -

Sr. Não Tipo e descrição da chamada
1 Chamada por valor

Este método copia o valor real de um argumento para o parâmetro formal do subprograma. Nesse caso, as alterações feitas no parâmetro dentro do subprograma não têm efeito no argumento.
2 Chamada por referência

Este método copia o endereço de um argumento no parâmetro formal. Dentro do subprograma, o endereço é usado para acessar o argumento real usado na chamada. Isso significa que as alterações feitas no parâmetro afetam o argumento.

Por padrão, Pascal usa call by valuepara passar argumentos. Em geral, isso significa que o código dentro de um subprograma não pode alterar os argumentos usados ​​para chamar o subprograma. O programa de exemplo que usamos no capítulo 'Pascal - Funções' chamou a função chamada max () usandocall by value.

Enquanto o programa de exemplo fornecido aqui ( exProcedure ) chama o procedimento findMin () usandocall by reference.