Procedimentos e funções são formas de escrever subprogramas na linguagem Pascal. Estes códigos só são executados quando ativados no programa principal.
Assim é feita a declaração de um procedimento:
procedure <identificador> ( <lista de parametros> ); (* cabecalho do procedimento *) begin (* corpo do procedimento *) end;
Uma função, por sua vez, é declarada desta forma:
function <identificador> ( <lista de parametros> ) : <tipo>; (* cabecalho da funcao *) begin (* corpo da funcao *) end;
As palavras procedure e function são reservadas. O corpo de um procedimento ou de uma função é constituído por comandos da mesma maneira que o programa principal (ver seção programaprincipal), com a diferença de que, nos subprogramas, os comandos só são executados quando o procedimento ou a função tiverem sido invocados.
O cabeçalho de um procedimento ou de uma função é constituído da mesma maneira que o cabeçalho do programa principal. Isto é, permite a declaração de constantes, de variáveis ou de tipos. A diferença reside no fato de que, tais elementos, possuem abrangência (escopo) local e não estão acessíveis a outros subprogramas ou ao programa principal.
Uma variável declarada em um subprograma existe somente durante a execução deste. Pode, inclusive, ter o mesmo nome de um identificador previamente usado, seja em outro subprograma, seja até no programa principal.
A lista de parâmetros é uma sequência (que pode ser vazia) de nomes de identificadores, separados por vírgula (“,”) com seus respectivos tipos precedidos por dois-pontos (“:”). Para cada novo tipo, deve-se usar o separador ponto-e-vírgula (“;”). Os parâmetros são argumentos repassados ao procedimento ou à função em foco.
O retorno, característica específica de funções, tem o respectivo tipo definido após a lista de parâmetros, precedido por dois pontos (“:”). O valor de retorno é especificado através de uma atribuição ao identificador da função, como se este fosse uma variável do tipo definido como retorno.
O compilador não aceita tipos estruturados como parâmetro ou como retorno de subprogramas, a menos que estes tenham sido previamente definidos pelo programador na seção de declaração de tipos.
A linha que contém o cabeçalho do procedimento ou função define a assinatura ou protótipo do subprograma, isto é, estabelece o nome, os parâmetros com respectivos tipos e, no caso das funções, o tipo de retorno.
Os parâmetros podem ser passados de duas maneiras, tanto para procedimentos quanto para funções: por valor ou por referência. Na assinatura do subprograma, a diferença é que os parâmetros passados por referência levam a palavra var antes da lista de parâmetros.
Os parâmetros passados por valor recebem uma cópia dos valores das variáveis usadas como argumento na chamada do subprograma. Os parâmetros passados por referência remetem, na verdade, à própria variável; que sofrerá todas as alterações realizadas.
Os subprogramas são invocados ou no programa principal ou por outro subprograma da seguinte maneira:
- Os procedimentos são invocados pelo seu nome e lista de argumentos, da mesma maneira como se invocaria um comando qualquer da linguagem, garantindo-se o número de parâmetros da assinatura do subprograma e os respectivos tipos;
- As funções são invocadas também por seu nome e lista de argumentos, contudo a invocação deve ser feita onde se espere um valor do mesmo tipo que o retorno da função virá a fornecer. Assim, se determinada função retornar um valor real, pode-se invocá-la em qualquer lugar onde se admita um valor real.
É importante observar que o compilador faz a checagem do número de parâmetros e respectivos tipos da lista de argumentos do cabeçalho do subprograma com os mesmos itens da ativação deste. Caso o número de argumento, a ordem, ou os tipos não compatibilizem, o compilador acusa erro.
Exemplos:
Neste primeiro exemplo, o procedimento aloMamae é ativado pelo programa principal.
program umProcedimento;
procedure aloMamae;
begin
writeln;
writeln('Alo Mamae!!!');
writeln;
end;
begin
aloMamae;
end.
Aqui, faz-se a chamada do procedimento perfil. São passados como parâmetro o nome, a idade e o peso do indivíduo. Embora, as variáveis globais sejam denominadas n, i e p, elas poderiam perfeitamente se chamarem nome, idade e peso, visto que as variáveis do procedimento perfil têm escopo local.
program outroProcedimento;
procedure perfil(nome : string; idade : integer; peso : real);
begin
writeln('Nome: ', nome);
writeln('Idade: ', idade);
writeln('Peso: ', peso);
end;
var
n : string;
i : integer;
p : real;
begin
n := 'Blaise Pascal';
i := 39;
p := 70.5;
perfil(n, i, p);
end.
Este terceiro exemplo apresenta um procedimento em que alguns parâmetros são agrupados por tipo no cabeçalho.
procedure variosTipos(a, b : integer; c : real; d : integer);
begin
writeln('Inteiros: ', a, ' e ', b);
writeln('Real: ', c);
writeln('Novamente inteiro: ', d);
end;
Neste quarto exemplo é mostrado como se faz a passagem de parâmetro por referência em um procedimento. Para funções, a sintaxe também é válida.
program porReferencia;
procedure duplica(var n : integer);
begin
n := 2 * n;
end;
var
numero : integer;
begin
numero := 10;
duplica(numero);
writeln(numero);
end.
Exemplo que expõe um procedimento recursivo que conta de um inteiro n até zero.
procedure contaAteZero(n : integer);
begin
if (n >= 0) then
begin
writeln(n);
contaAteZero(n - 1);
end;
end;
Aqui, apresenta-se um exemplo em que se utiliza um tipo estruturado, predefinido, como parâmetro.
program tipoEstruturado;
type
vetor10int = array [1..10] of integer;
procedure exibeVetor(v : vetor10int);
var
i : integer
begin
writeln;
writeln('Vetor digitado:');
for i := 1 to 10 do
writeln(v[i]);
end;
var
i : integer;
vetor : vetor10int;
begin
for i := 1 to 10 do
begin
writeln('Digite um valor para a posicao ', i, ':');
readln(vetor[i]);
end;
exibeVetor(vetor);
end.
Neste outro exemplo, evidencia-se a chamada, a passagem de parâmetro e o retorno de uma função que recebe duas notas inteiras e devolve a média anual (um valor real) de um aluno.
program calculoDaMedia;
function media(nota1, nota2 : integer) : real;
begin
media := (nota1 + nota2) / 2;
end;
var
a, b : integer;
begin
writeln('Digite a media do primeiro semestre:');
readln(a);
writeln('Digite a media do segundo semestre:');
readln(b);
writeln('Media anual: ', media(a, b));
end.
Por fim, este exemplo apresenta o uso uma função recursiva que retorna o n-ézimo elemento da série de Fibonacci.
function fibonacci(n : integer) : integer;
begin
if (n < 3) then
fibonacci := 1
else
fibonaci := fibonacci (n-1) + fibonacci(n-2);
end;
