PROCEDURE: Sub-rotina que processa informa��es e n�o retorna valor.

FUNCTION: Sub-rotina que processa informa��es e retorna um valor

.
Uma Function pode receber nenhum, um ou v�rios par�metros de entrada e retornar
um determinado valor, vamos a sintaxe b�sica:

///**************************************
unction NomeFun��o(Par�metro1:Tipo;Par�metro2:Tipo): Tipo de Retorno;
Var
{declara��o de vari�veis se necess�rio}
Begin
{Instru��es}
//Para retornar o valor desejado podemos usar a palavra reservada Result.
Result := Valor de Retorno;

//ou o nome da fun��o.

NomeFun��o := Valor de Retorno;
End;

Um Procedure pode receber nenhum, um ou v�rios par�metros de entrada mas n�o

retorna
nenhum tipo de valor, salvo exce��es que explico mais adiante.

procedure NomeProcedure(Par�metro1:Tipo;Par�metro2:Tipo);
Var
{declara��o de vari�veis se necess�rio}
Begin
{Instru��es}
End;

Vamos ao exemplo de uma fun��o muito popular na internet para somar dois valores
inteiros e retornar um valor inteiro. Notem que essa fun��o vai receber 2
par�metros
do tipo integer e retornar a soma que � do tipo integer.

function Soma(a, b: integer): integer;

begin
//Retorna o valor da soma a + b.
Result := a + b;
end;

Agora um exemplo de procedure que vai receber um valor inteiro e verificar se esse
valor � par ou �mpar, ao final emite uma mensagem na tela.

Listagem 4: Procedure para verificar se o valor � par ou �mpar

procedure VerificaParImpar(a: integer);

begin
if a mod 2 = 0 then
ShowMessage('N�mero par!')
else
ShowMessage('N�mero �mpar!');
end;

Notem que a procedure emite uma mensagem avisando se o valor � par ou �mpar, essa
mensagem n�o pode ser considerada com um valor de retorno mas sim parte das
instru��es de processamento das informa��es. J� no caso da function ela processa a
soma de �a + b� e retorna o valor da soma, podemos atribuir esse valor a um
determinado componente ou vari�vel, na procedure n�o podemos executar esse tipo de
atribui��o, pois ela n�o possui valor de retorno.

Par�metros:
Como j� foi mencionado se necess�rio podemos passar par�metros para functions e
procedures, esses par�metros podem ser por valor ou refer�ncia.

Valor: Nos 2 exemplos acima foram passados par�metros por valor, ou seja,
internamente no compilador ser� preenchido o par�metro que est� entre par�nteses
com uma c�pia do valor de origem, para que esse valor seja usado dentro da function
ou procedure, mas o valor original n�o ser� alterado, exemplo:

Listagem 5: Exemplo de par�metro por valor

procedure TForm1.btn1Click(Sender: TObject);

var
a, b: Integer;
begin
//Inicia "a" com valor 1
a := 1;
//Vari�vel "b" recebe o valor de retorno da fun��o SomaValor passando a
vair�vel "a" como par�metro.
b := SomaValor(a);
//Emite mensagem com os valores
ShowMessage('Valor de (a) antes chamada da fun��o: ' + IntToStr(a) + #13 +
'Valor de (b) ap�s chamada da fun��o: ' + IntToStr(b) + #13 +
'Valor de (a) ap�s chamada da fun��o: ' + IntToStr(a));
end;

function TForm1.SomaValor(x: integer): Integer;

begin
//Adiciona 1000 ao valor de a
x := x + 1000;
//Retorna o valor de a
Result := x;
end;

Notem que n�o houve altera��o no valor da vari�vel �a� mesmo ap�s a chamada da
fun��o, isso porque o valor de �a� foi copiado para o par�metro �x� da fun��o
SomaValor, sendo assim podemos alterar valores de �x� porque ela n�o tem v�nculo
com a vari�vel �a�.

Refer�ncia: Podemos modificar esse contexto se utilizarmos na assinatura da

function antes do nome do par�metro a palavra reservada �var�, isso indica que ser�
passado o endere�o da vari�vel �a� como par�metro e n�o mais a c�pia do valor como
anteriormente. Desse modo toda e qualquer altera��o no valor de �x� dentro da
function ser� revertida para vari�vel �a�, exemplo:

Listagem 6: Exemplo de par�metro por refer�ncia

function TForm1.SomaValor(var x: integer): Integer;

begin
//Adiciona 1000 ao valor de a
x := x + 1000;
//Retorna o valor de a
Result := x;
end;
Nesse exemplo utilizamos uma function, tamb�m poder�amos usar sem problemas uma
procedure at� porque n�o retornamos valor mas sim alteramos o valor da vari�vel
�a�, isso porque passamos o endere�o dessa vari�vel como par�metro. Ainda usando
�var� podemos passar qualquer tipo objeto como refer�ncia desde componentes da VCL
at� objetos instanciados a partir de classes criadas por n�s mesmos.

Existe outra situa��o muito interessante nos par�metros das procedures que podemos
usar com muita efici�ncia, no in�cio do artigo mencionei que uma �procedure n�o
retorna nenhum tipo de valor, salvo exce��o�. Essa exce��o se aplica ao uso da
palavra reservada �out�. Quando declararmos a palavra �out� antes do par�metro,
estamos indicando que ele vai receber um valor de sa�da da procedure, mas alguns
leitores podem se questionar �Procedure n�o retorna valores!�, � verdade mas nesse
caso estamos declarando que esse par�metro que nada mais � que uma refer�ncia a uma
vari�vel, vai receber um determinado valor ap�s o processamento interno da
procedure e consequentemente podemos acess�-lo ap�s a chamada da procedure,
acompanhem o exemplo abaixo:

Listagem 7: Exemplo de par�metro �out�

procedure TForm1.btn3Click(Sender: TObject);

var
a, retorno: Integer; //vari�vel "retorno" para capturar o retorno da procedure
begin
//Atribui 1 para vari�vel "a"
a := 1;
//Chama a procedure SomaValor2 e passa como par�metro a vari�vel "a"
//e como par�metro de sa�da vari�vel "retorno"
SomaValor2(a,retorno);
//Emiti mensagem com o valor da vari�vel "retorno"
ShowMessage('Valor da vari�vel (retorno): ' + IntToStr(retorno));
end;

procedure TForm1.SomaValor2(x: integer; out saida: Integer);

begin
//Adiciona 1000 ao valor de "x"
x := x + 1000;
//Atribui o valor de "x" ao par�metro saida que foi declarado como "out"
saida := x;
end;

Notem que antes de chamarmos a procedure com par�metro �out� de retorno temos que
declarar uma vari�vel do mesmo tipo do par�metro, essa vari�vel vai receber o
resultado da procedure, caso fosse atribu�do algum valor para vari�vel �retorno�
antes da chamada da procedure esse valor seria desprezado.

Declara��o:
No Delphi todas as procedures e functions s�o declaradas na se��o interface, o
programador define o escopo da fun��o private, public s�o os mais utilizados, segue
exemplo da declara��o das functions e procedures desse artigo.

Listagem 8: Declara��o das functions e procedures

unit UPrincipal;

interface

uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
 Dialogs, StdCtrls;

type
TForm1 = class(TForm)
btn1: TButton;
btn2: TButton;
btn3: TButton;
procedure btn1Click(Sender: TObject);
procedure btn3Click(Sender: TObject);
private
function SomaValor(x: integer): Integer;
function SomaValorRef(var x: integer): Integer;
procedure SomaValor2(x: integer; out saida: Integer);
public
{ Public declarations }
end;
Podemos ainda declarar uma function ou procedure dentro de outra procedure,
lembrando que ela s� ser� vis�vel dentro da procedure de origem, semelhante a
escopo das vari�veis declaradas dentro das procedures s� ficam vis�veis
internamente. Desse modo n�o � necess�rio declarar na se��o interface.

Listagem 9: Declara��o das functions e procedures dentro de outra procedure

procedure TForm1.btn4Click(Sender: TObject); //Procedure principal

//Declara��o interna da function
function Somar(a, b: integer): Integer;
begin
Result := a + b;
end;

var
resultado: Integer;
begin
//Chamando function interna
resultado := Somar(10, 20);
ShowMessage('Valor da soma: ' + IntToStr(resultado));
end;

Chamadas:
Para chamar uma function ou procedure � muito simples, no caso da function basta
digitar o mesmo nome da assinatura da mesma, sendo precedida ou n�o de par�nteses,
depende da necessidade de passar par�metros, atribuir o valor de retorno para uma
vari�vel do mesmo tipo de retorno da function.

Listagem 10: Chamada de uma function

var
resultado: Integer;
begin
//Chamando function, passa os par�metros e atribui o valor de retorno
resultado := Somar(10, 20);
ShowMessage('Valor da soma: ' + IntToStr(resultado));
end;
No caso da procedure, como n�o existe um valor de retorno basta digitar o mesmo
nome da assinatura da mesma, sendo precedida ou n�o de par�nteses, depende da
necessidade de passar par�metros.

Listagem 11: Chamada de uma procedure

begin
//Chamando procedure com par�nteses.
EmitirMensagem();
ou
//Chamando procedure sem par�nteses.
EmitirMensagem;
end;
Bom pessoal, demonstrei nesse artigo princ�pios b�sicos de functions e procedures.
Como o nosso Delphi difere alguns conceitos em rela��o � algumas linguagens como
Java e C#, � sempre bom pegar essas dicas principalmente para quem est� chegando no
Delphi.

Espero que tenham apreciado esse artigo e at� a pr�xima.