Protótipos de funções

Não podemos usar uma função sem declará-la previamente. Trata-se duma instrução geralmente colocada no início do programa ou do arquivo, obrigatoriamente antecedendo a definição e a chamada da função.

O protótipo informa ao compilador o tipo que a função retorna, o nome da função, bem como os parâmetros que ela recebe. Eis um exemplo:

double diametro (int raio);

Esse protótipo está declarando uma função chamada diametro, que recebe um valor inteiro (a declaração int dentro dos parênteses: diametro(int raio)) e devolve um valor ponto flutuante (o double que antecede o nome da função: double diâmetro()). Poderiam ser quaisquer outros tipos.

O protótipo e a definição da função devem conter o mesmo nome, o mesmo tipo retornado e a mesma lista de parâmetros:

double diametro(int raio); // Protótipo da função: com ponto e vírgula após os parênteses

double diametro(int raio) // Definição da função: sem ponto e vírgula
{ // chave de abertura do corpa da função
return raio * 3.14; // única instrução dessa função
} // chave de encerramento da função

O nome da variável passada como parâmetro (em nosso exemplo, a inteira raio) é facultativo, mas o tipo é obrigatório. Quanto ao valor de retorno será um tipo, ou será void (caso não haja valor de retorno):

void diametro(int raio); // Protótipo da função

Se nenhum tipo for especificado como valor de retorno, o compilador retornará o tipo int:

O exemplo:

//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
Experimenta_Tipos(char raio); // Protótipo da função
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Label1Click(TObject *Sender)
{
// o caption de Label1 chama diametro e passa o caracter 'a' como parâmetro
/* IMPORTANTE: em qualquer hipótese, na chamada à função não podemos colocar
o tipo de retorno, pois o compilador retornará mensagem de  ERRO*/
Label1 -> Caption = /*sem tipo de retorno*/Experimenta_Tipos('a'); 
}
//---------------------------------------------------------------------------

Experimenta_Tipos(char raio) /* Definição da função sem tipo especificado 
para retorno. A função retornará como sendo int */
{ 
// 'a' equivale a 97 na tabela ASCII. 
return raio * 1000.01; 
}

terá como valor de retorno: 97000.

Experimente, nesse mesmo exemplo, colocar como valor de retorno o tipo char. Depois faça o mesmo como o tipo double. Com essas pequenas pequenas alterações, você poderá visualizar os diferentes comportamentos do compilador.

Além da forma de declaração apresentada (protótipo externo, pois é escrito fora e antes das funções), existe a possibilidade de declararmos o protótipo dentro do corpo de cada função chamadora (protótipo interno).

Para esses casos, há duas restrições:

1ª. A função é visível apenas dentro do bloco onde estiver o seu protótipo;

2ª. devemos declarar o tipo retornado no protótipo (ou void), para que o compilador não interprete o protótipo como uma chamada à função e, conseqüentemente, retorne uma mensagem de erro:

//---------------------------------------------------------------------------

void __fastcall TForm1::Label1Click(TObject *Sender)
{
char Experimenta_Tipos(char raio); // Protótipo da função
Label1 -> Caption = /*sem tipo de retorno*/Experimenta_Tipos('a');
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)
{
char Experimenta_Tipos(char raio); // Protótipo da função
Label2 -> Caption = /*sem tipo de retorno*/Experimenta_Tipos('a');
}
//---------------------------------------------------------------------------