Amarrações

Declaração de Constantes

Constantes são valores especiais que geralmente são definidos no ínicio do programa e, se destinam a armazenar informações ou valores que não se alteram ao longo da execução do programa. Veja abaixo um exemplo de declaração de constantes no Delphi.

Const

PI = 3.1416;

Linguagem : String = ‘Delphi’;

dia : array [0..6] of String[9] = ('Domingo' , 'Segunda' , 'Terça' , 'Quarta' , 'Quinta' , 'Sexta', 'Sábado');

As declarações de constantes não alocam recursos do sistema. De fato, isto somente ocorre quando elas forem utilizadas na aplicação. Contudo, a constante Linguagem terá um tratamento diferente, uma vez que ela é uma constante tipada, ou seja, seu tipo (string) já foi previamente definido.

A maior diferença entre constantes do C e do Object Pascal é que Object Pascal, assim como Visual Basic, não requer que você declare o tipo constante junto com o valor na declaração. O compilador do Delphi automaticamente aloca espaço apropriado para a constante baseado nos seus valores, ou, no caso de constantes escalares tais como Inteiros, o compilador fiscaliza os valores que ele manipula, e espaços nunca são alocados.

Os valores das constantes são substituídos em tempo de compilação. Ou seja, os valores são definidos estaticamente.

Declaração de Variáveis

Sempre que desenvolvemos nossas aplicações, surge a necessidade de armazenarmos temporariamente certas informações. Para isto utilizamos variáveis. No Delphi podemos Ter diversos tipos de variáveis com características de armazenamento próprias.

Tais variáveis devem ser sempre bem definidas antes de tentarmos utilizá-las. Ao definir ou declarar uma variável, indique seu nome seguido do tipo de informação que deseja que ela armazene.

As variáveis estão dispostas em cinco grupos:

Numéricas: Podem ser números inteiros ou reais, formadas pelos dígitos de 0 a 9, sinais + e - podendo também conter o “.” para determinar a casa decimal.

Alfanuméricas: Podem ser formadas pôr qualquer tipo de caractere da tabela ASCII.

Lógicas: Podem assumir apenas dois valores: TRUE para valores verdadeiros ou FALSE para falsos.

Data/Hora: Podem armazenar data e hora, permitindo um processamento simples de data/hora.

Ponteiros: Podem armazenar apenas endereços de memória.

O nome da variável deve ser único em cada bloco do programa e deve conter até 255 caracteres, podendo ser composto pôr letras, números e sublinhado “_” , porém serve sempre iniciar com uma letra e não pode ser uma palavra reservada pelo Object Pascal.

É aconselhável que defina o nome da variável de forma que esta nós lembre a função que ela terá no contexto do programa. Além disso, o nome de uma variável não deve conter símbolos especiais (p.e. &%#@!), , nem ser igual ao nome de uma palavra reservada do Object Pascal.

O formato de declaração de variáveis deve ter a seguinte sintaxe:

VAR

nome_da_variável [, nome_da_variável ...] : tipo;

Exemplo N_Pessoas : Byte;

:

Var

Nome, SobreNome : String;

Idade : Integer;

O compilador Delphi entende que todos os dados globais são automaticamente inicializados com zero. Quando sua aplicação é iniciada, todo tipo inteiro possui 0, tipos ponto-flutuante possuem 0.0, ponteiros serão nil, strings estarão vazias, e assim em diante.Então, não é necessário inicializar com zero dados globais em seu código fonte.

Procedimentos e Funções

Como um programador, você já deve estar familiarizado com os conceitos de funções e procedimentos. Um procedimento é uma parte discreta do programa que efetua alguma tarefa particular quando ele é chamado e então retorna a parte do seu código que o chamou. Uma função trabalha da mesma forma exceto pelo fato de que ela retorna um valor depois de sua saída para a parte do programa que a chamou.

Se você está familiarizado com C ou C++, considere que um procedimento em Pascal é equivalente a uma função em C ou C++ que retorna void, enquanto que uma função corresponde a uma função do C ou C++ que retorna um valor.

A variável local Result na função merece atenção especial. Toda função em Object Pascal tem uma variável local implícita chamada Result que contém o valor de retorno da função. Note que diferentemente de C e C++, a função não termina assim que um valor é atribuído a Result.
Você também pode retornar um valor de uma função atribuindo ao nome de uma função o valor dentro do código da função. Esta é a sintaxe padrão do Pascal e costume das versões anteriores do Borland Pascal.

Passando Parâmetros

Pascal possibilita que você passe parâmetros por valor ou por referência para funções e procedimentos. Os parâmetros que você passa podem ser de qualquer tipo básico ou definido pelo usuário, ou open array (open arrays serão discutidos nesse tutorial). Parâmetros também podem ser constantes se seus valores não mudarem no procedimento ou função.

Parâmetros Valor

Parâmetros valor são o modo default de passagem de parâmetros. Quando um parâmetro é passado por valor, significa que uma cópia local daquela variável é criada, e a função ou procedimento opera sobre a cópia. Considere o exemplo a seguir:

procedure Foo(s: string);

Quando você chama um procedimento desta forma, uma cópia da string s será criada, e Foo() operará sobre a cópia local de s. Isto significa que você pode escolher o valor de s sem ter qualquer efeito sobre a variável passada para dentro de Foo().

Parâmetros Referência

Pascal permite que você passe variáveis para funções e procedimentos por referência; parâmetros passados por referência são também chamados parâmetros variáveis. Passar por referência significa que a função ou procedimento ao receber a variável pode modificar o valor daquela variável. Para passar uma variável por referência, use a palavra var na lista de parâmetros da função ou procedimento:

procedure ChangeMe(var x: longint);
begin
x := 2; { x agora é alterado na chamada do procedimento }
end;

Em vez de fazer uma cópia de x, a palavra reservada var faz com que o endereço do parâmetro seja copiado de forma que seu valor possa ser diretamente alterado.

Usar parâmetros var é equivalente a passar variáveis por referência em C++ usando o operador &. Assim como o operador & do C++, a palavra var faz com que o endereço da variável seja passado para a função ou procedimento, e não o valor da variável.

Parâmetros Constantes

Se você não quiser que o valor de um parâmetro passado para dentro de uma função seja alterado, você pode declará-lo com a palavra chave const. const não apenas impede que você modifique o valor dos parâmetros, mas ele também gera código mais otimizado para strings e registros passados para dentro de procedimentos ou funções. Aqui está um exemplo de uma declaração de procedimento que receber um parâmetro string constante:

procedure Goon(const s: string);

Parâmetros Open Array

Parâmetros open array permite que você passe um número variável de argumentos para funções e procedimentos. Você pode passar ou open arrays de algum tipo homogêneo ou arrays constantes de tipos diferentes. O código seguinte declarar uma função que aceita um open array de inteiros:

function AddEmUp(A: array of Integer): Integer;

Você pode passar variáveis, constantes ou expressões constantes para funções ou procedimentos de open array. O código a seguir demonstra isto chamando AddEmUp() e passando uma variedade de elementos diferentes.

var
i, Rez: Integer;
const
j = 23;
begin
i := 8;
Rez := AddEmUp([i, 50, j, 89]);

Para funcionar com um open array dentro de um a função ou procedimento, você pode usar as funções High(), Low() e SizeOf() para obter informação sobre o array. Para ilustrar isto, o código seguinte mostra uma implementação da função AddEmUp() que retorna a soma de todos os números passados em A:

function AddEmUp(A: array of Integer): Integer;
var
i: Integer;
begin
Result := 0;
for i := Low(A) to High(A) do
inc(Result, A[i]);
end;

Escopo

Escopo refere-se a alguma parte de seu programa na qual uma dada função ou variável é conhecida pelo compilador. Uma constante global está no escopo em todos os pontos de seu programa, por exemplo, enquanto uma variável local para algum procedimento tem escopo apenas dentro daquele procedimento.
program Foo;


const
AlgumConstant = 100;

var
AlgumGlobal: Integer;
R: Real;

procedure AlgumProc(var R: Real);
var
LocalReal: Real;
begin
LocalReal := 10.0;
R := R - LocalReal;
end;

begin
AlgumGlobal := AlgumConstant;
R := 4.593;
AlgumProc(R);
end.

AlgumConstant, AlgumGlobal e R tem escopo global—seus valores são conhecidos pelo compilador em todos os pontos dentro do programa. O procedimento AlgumProc() tem duas variável na qual o escopo é local para aquele procedimento: R e LocalReal. Se você tentar acessar LocalReal fora de AlgumProc(), o compilador mostrará um erro de identificador desconhecido. Se você acessar R dentro de AlgumProc(), você estará referindo a versão local, mas se você acessar R fora daquele procedimento, você estará referindo à versão global.

Object Pascal permite o uso de funções em tempo de compilação em declarações const e var. Essas rotinas incluem: Ord(), Chr(), Trunc(), Round(), High(), Low(), e SizeOf(). Por exemplo, todos os códigos seguintes são válidos:

type
A = array[1..2] of Integer;

const
w: Word = SizeOf(Byte);

var
i: Integer = 8;
j: SmallInt = Ord(‘a’);
L: Longint = Trunc(3.14159);
x: ShortInt = Round(2.71828);
B1: Byte = High(A);
B2: Byte = Low(A);
C: char = Chr(46);