Unit/pt

From Free Pascal wiki
Jump to: navigation, search

Deutsch (de) English (en) español (es) suomi (fi) français (fr) português (pt)

Uma unit é um arquivo de código fonte (ou o binário compilado a partir desse arquivo) o qual foi escrito usando um dialeto da linguagem de programação Pascal. Uma unit foi planejada para ser uma unidade, um módulo único de uma aplicação ou um módulo objeto.

Objetivo

Uma unidade pode ser usada onde funcionalidade necessita ser fornecida, seja a um programa de computador, a um módulo objeto ou a outras unidades. Ela permite escrever código que implementa essa funcionalidade uma vez e a usa em diferentes lugares. Ao se aumentar a reutilização de uma unidade cujo código já é conhecido e testado, a chance de erro humano se reduz.

Uma unidade binária pode ser usada quando o autor de uma unidade deseja fornecer uma funcionalidade a um programa Pascal, mas não pode fornecer o código fonte correspondente àquela funcionalidade.

Em versões antigas do Pascal, unidades também eram usadas em computadores com recursos limitados. Elas eram necessárias por serem capazes de carregar rotinas por demanda ao invés de deixá-las na memória do programa executável todo o tempo.

Uma unidade que precise acessar, e. g.  procedimentos e tipos de dados em outra unidade, precisa especificar essa unidade por meio da cláusula Uses. Uma vantagem é que o processo de ligação entre unidades e executável (linking) é feito sem a necessidade de se escrever arquivos de tipo "makefile", como na linguagem de programação C.

Uma unidade pode ainda ser usada para se declarar uma série de constantes ou variáveis globais, sem necessariamente conter qualquer código executável. Isso é similar à palavra-chave common na linguagem de programação Fortran.

Formato

Uma unidade é definida com a palavra-chave unit seguida por um identificador de uma unidade. O identificador da unidade (no exemplo a seguir o nome da unidade é "minimalunit") deve corresponder ao nome do arquivo da unidade no qual ele está escrito. Um exemplo mínimo seria:

unit minimalunit;
interface
	{ declarações de funcionalidade pública, ao se
          incluir esta unidade por meio da cláusula 'uses' }
implementation
	{ implementação de funcionalidade pública }
	{ implementação de funcionalidade privada,
          acessível apenas por esta unidade, é opcional }
end.

onde a parte após interface corresponde ao públicamente acessível por outras unidades e implementation ao acessível apenas a unidade 'minimalunit' de forma privada.

Uma outra estrutura mínima mais avançada seria:

unit advancedunit;
interface
        { público ao se incluir na cláusula 'uses' }
implementation
        { privado }
initialization
	{ código executado quando a unidade é inicializada,
         ao início do programa }
 
finalization
	{ código executado quando a unidade é finalizada,
         ao final do programa }
 
end.

Os blocos initialization e finalization são opcionais.


Exemplo detalhado de uma unidade

{
 
  Descrição da unidade.
 
}
unit randomunit;
 
{ essa unidade não depende de outras unidades, mas poderia depender }
// uses SomeOtherUnit, YetAnotherUnit;
 
{ público }
interface
 
type
  { o tipo TRandomNumber torna-se acessível 
    desde que a unidade seja incluida por meio da cláusula 'uses' }
  TRandomNumber = integer;
 
{ outros blocos também podem ser incluídos, type, const, var, resourcestring }
 
{ a assinatura de procedimentos e funções torna-os
  acessíveis desde que a unidade seja incluida por meio da cláulusa 'uses' }
function getRandomNumber(): TRandomNumber;
 
{ um método não pode ser implementado na interface }
 
{ privado }
implementation
 
{ essa unidade não depende de outra unidade, mas poderia depender }
// uses SomeOtherUnit;
 
{ variáveis acessíveis e modificaveis apenas nesta unidade  }
var
  chosenRandomNumber: TRandomNumber;
 
function getRandomNumber(): TRandomNumber;
begin
  Result := chosenRandomNumber;
end;
 
{ ao início do programa }
initialization
begin
  chosenRandomNumber := 3;
end;
 
{ ao final do programa }
finalization
begin
  WriteLn('bye');
end;
end.
{
  Program 
}
program chooseNextCandidate;
 
{ usar unidade }
uses
  randomunit;
 
begin
  WriteLn('Próximo Candidato:' + getRandomNumber());
end.

Ao compilar, as dependências do programa serão conferidas. O compilador deve ser capaz de encontrar o arquivo "ramdomunit.pas" da unidade "randomunit". A maneira mais simples de assegurar isso é manter o nome do arquivo .pas idêntico ao nome da unidade, manter o arquivo na mesma pasta do arquivo do programa ou assegurar que o caminho do diretório do arquivo da unidade é conhecido pelo compilador (FPC).

Precedência de unidade

Quando múltiplas unidades constam na cláusula 'uses' conflitos entre identificadores (procedures, types, functions, etc) com nomes idênticos podem ocorrer. Quando isso ocorre, "a última unidade ganha" e fornece o código.

Se você quiser usar o código de uma unidade que "perdeu", você pode:

1) usar o nome da unidade como prefixo do identificador unidade.identificador; 2) reordenar as unidades;

A primeira opção é a mais clara.

Veja também