Pascal para Delphi ®

Sumário

Introdução 03

Pascal – base para o Delphi 03

Object pascal 03

Orientação para eventos 03

Programas e units 04

Visão geral 04

Estrutura simplificada de um programa 04

Units 05

Estrutura da unit 05

Programas e units no Delphi 05

Exemplo 1 07

Exemplo 2 10

Adicionando comentários ao programa 11

Exemplo 3 11

Tipos de dado, variáveis e operadores 12

Tipos de dados 12

Variáveis 12

Exemplo 4 13

Exemplo 5 14

Convertendo dados 14

Constantes 16
1
 Pascal para Delphi ®

Palavras reservadas 16

Operadores e expressões 17

Exemplo 6 18

Procedures e funções 19

Introdução a procedures e funções 19

Criando procedures 19

Criando funções 21

Posicionando a procedure ou função na unit 23

Exemplo 7 23

Chamando a procedure ou função 25

Exemplo 8 25

Passagem de parâmetros por valor ou referência 27

Exemplo 9 27

Comandos condicionais 30

Visão geral 30

If...then 30

Exemplo 10 31

Case...of 34

Exemplo 11 35

Comandos de repetição 38

Visão geral 38

While...do 38

Exemplo 12 38

For...do 40

Exemplo 13 41

2
 Pascal para Delphi ®

Repeat...until 42

Exemplo 14 43

Manipulando strings 45

Visão geral 45

Funções de manipulação de strings 45

Procedure de manipulação de strings 48

Rotinas aritiméticas 50

Visão geral 50

Principais rotinas 50

Exemplo 15 54

Outros tipos de dados 55

Visão geral 55

Arrays 55

Exemplo 16 55

Exemplo 17 56

Strings 57

Registros 57

Exemplo 18 57

Tipo enumerado 58

Tipo set 59

Tipo intervalo 59

Comandos de entrada e saída de arquivos 60

Tipos de arquivos 60

Trabalhando com arquivos texto 60

Comandos de manipulação de arquivos texto 61

3
 Pascal para Delphi ®

Exemplo 19 70

Trabalhando com arquivos binários 71

Comandos de manipulação de arquivos binários 71

Exemplo 20 79

Manipulando arquivos não tipados 79

Rotinas de gerenciamento de arquivos 81

Exemplo 21 89

Outras rotinas de manipula cão de arquivos 89

Exemplo 22 91

Imprimindo arquivos 91

Exemplo 23 91

Conceitos básicos de orientação a objetos 93

Objetos 93

Atributos ou propriedades 93

Serviços ou métodos 94

Classes 95

Relacionamento entre classes 96

Menssagens 98

Código orientado a objetos em pascal 100

Orientação a objetos em pascal 100

Exemplo 24 101

4
 Pascal para Delphi ®

Pascal - Base do Delphi

O lançamento do Delphi, em 1995, deu um novo estímulo ao uso do Pascal, já que esta é a linguagem em
que o Delphi se baseia. Na verdade, o Delphi é um ambiente de programação, baseado na linguagem
Pascal, e não uma nova linguagem de programação.

Atualmente, a Borland oferece três versões para o Pascal: o Turbo Pascal 7.0, para ambiente DOS, o
Pascal for Windows 1.5, e o Delphi, já na versão 4.0.

Como o Delphi se baseia na linguagem Pascal para a construção de programas, é interessante conhecer a
fundo esta linguagem, para que seu trabalho com o Delphi seja produtivo. O aprendizado do Delphi como
ambiente de programação é um pouco extenso; conhecer bem a linguagem em que este se baseia facilita a
experiência.

O Object Pascal

Apesar de se basear na linguagem Pascal padrão, o Delphi implementa alguns comandos novos,
notadamente na parte de criação de classes e objetos.

Estes novos comandos serão vistos neste livro, e o alertaremos quanto ao seu uso em outros compiladores
Pascal. Por causa destes comandos adicionais, o Pascal do Delphi é conhecido como Object Pascal.

O segundo ponto que devemos ressaltar é que, por ser um ambiente de programação que roda sobre o
Windows, um programa em Delphi dificilmente usa os comandos de entrada e saída de dados em tela da
linguagem Pascal, como Readln e Writeln, próprios para o ambiente DOS.

A entrada e a saída de dados em tela estão ligadas aos componentes do Delphi inseridos no formulário da
aplicação, e às propriedades destes. Os comandos do Pascal só são usados quando desenvolvemos uma
aplicação em Delphi para rodar em ambiente DOS, portanto serão vistos apenas superficialmente.

Orientação para Eventos

Por fim, vale lembrar que por rodar em ambiente Windows, o Delphi gera programas orientados para
eventos. Eventos são ações geradas pelo usuário (como clicar em um botão, mover o mouse, selecionar
uma caixa de checagem) ou pelo sistema (como o carregamento de um formulário).

Portanto, o código do programa só é executado se estiver associado a determinado evento. Como o

objetivo deste livro não é analisar os componentes do Delphi, apenas ensinar a base do Pascal, para
executar os códigos utilizados nos exemplos não usaremos nenhum componente do Delphi, utilizando
apenas uma caixa de mensagem mostrada quando o aplicativo é executado.

5
 Pascal para Delphi ®

Visão Geral

Apesar de bem mais poderoso que qualquer outro compilador Pascal, como o Turbo Pascal, o ambiente
de programação Delphi é um pouco mais complexo do que os demais compiladores.

Ou seja, não é oferecido ao programador simplesmente uma tela em branco onde o código em Pascal é
inserido. Ao contrário, mesmo que nosso aplicativo Delphi não realize nenhuma operação, diversas linhas
de código são inseridas automaticamente pelo Delphi.

Inserir seu próprio código dentro do Delphi não é uma tarefa simples. Por isso iniciamos este livro
explicando de forma detalhada como o Delphi trabalha com programas e units. A partir deste capítulo,
poderemos dar ênfase completa ao Pascal.

Estrutura Simplificada de um Programa

Um programa simples em Pascal possui um cabeçalho, e um corpo, com a seguinte estrutura:

program nome_do_programa;

uses
units_usadas_pelo_programa;

begin
.....
end.

Iniciamos com o cabeçalho, que contém a palavra reservada program, seguida do nome que daremos ao
programa, e um ponto e vírgula:

program nome_do_programa;

Por exemplo, se o nome que daremos para o programa for PrimeiroPrograma, faríamos:

program PrimeiroPrograma;

Após o cabeçalho do programa segue a seção uses. Nesta seção declaramos o nome das units usadas por
nosso programa. Uma unit é um conjunto de procedimentos e funções que realizam determinada
operação, e serão vistas com mais detalhes na próxima seção.

Se seu programa usa a unit PrimeiraUnit, por exemplo, teríamos então:

program PrimeiroPrograma;
uses
PrimeiraUnit;

Após a seção uses, temos o corpo do programa, limitado pelas palavras reservadas begin e end:

begin
6
 Pascal para Delphi ®

.....
end.

Entre estas palavras colocamos a estrutura de nosso programa. Note que após a palavra end colocamos
um ponto final, que mostrará ao compilador que o programa terminou.

Units

Quando um programa é muito extenso, podemos dividí-lo em units. Uma unit é um conjunto de
procedures e funções que realizam determinada tarefa.

Seu programa pode ser então dividido em diversas units, cada uma com determinado objetivo. As units
criadas podem ser usadas não só pelo seu programa, mas por qualquer outro que você venha a
desenvolver. Como você imagina, isto torna seu trabalho bem mais produtivo. Basta você criar um
conjunto de units padrões para cálculos, acesso a dados, etc, e depois usá-las em seus diversos programas,
sem ter que reescrevê-las.

Estrutura das units

Programas e Units no Delphi

Quando você inicia um novo projeto no Delphi, ele já cria automaticamente um arquivo do tipo program
e uma unit, denominada Unit1.

Veja o arquivo do tipo program criado:

7
 Pascal para Delphi ®

Este arquivo é acessado através da opção Project | View Source. Note que na seção uses deste arquivo já
está incluída a Unit1, oferecida automaticamente pelo Delphi:

uses
Forms,
Unit1 in '[Link]' {Form1};

Veja a unit criada automaticamente pelo Delphi, acessada através de um clique sobre a aba
correspondente a Unit:

unit Unit1;

interface

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

type
TForm1 = class(TForm)
private
{ Private declarations }
public
{ Public declarations }
end;

var
Form1: TForm1;

8
 Pascal para Delphi ®

implementation

{$R *.DFM}

end.

Esta unit possui um cabeçalho, que a identifica como Unit1. Na seção interface, usa três cláusulas: uses,
type e var. A cláusula uses define as units que esta Unit1 usará. São units padrão do Delphi, que
oferecem, por exemplo, funções de conversão, quadros de mensagem, etc. Você não deve apagá-las.

Já as cláusulas type e var criam dados e variáveis ligados ao formulário, operação que veremos com mais
detalhes posteriormente. Você também não deve mexer nestas cláusulas.

Finalmente temos a seção implementation (sem nada implementado), uma diretiva de pré-processamento
(que também não deve ser apagada) e a palavra reservada end, seguida de um ponto final que finaliza a
unit.

A estrutura da unit vista acima é criada automaticamente pelo Delphi, e é a estrutura mínima que uma unit
deve ter para criar um aplicativo no Delphi.

Ou seja, no Delphi você não cria código em um arquivo do tipo program, apenas nas units. O arquivo do
tipo program serve apenas para inicializar a aplicação, e determinar que units fazem parte desta.

Exemplo 1

Vamos criar um programa que mostra em uma caixa de mensagem a frase 'Bem Vindo'. Para isso, vamos
ter que associar o código que mostra a frase a um evento. Para facilitar, vamos associar o código ao
evento de criação do formulário, que ocorre logo que o programa é executado, e o formulário é mostrado
na tela. Siga então os seguintes passos:

1) Entre no Delphi.

2) Clique sobre o formulário apresentado, e, no Object Inspector, vá para a ficha Events, e dê um duplo
clique no evento onCreate:

9
 Pascal para Delphi ®

3) Aparecem as seguintes linhas de código:

procedure [Link] (Sender: TObject);

begin

end;

4) Clique sobre a linha em branco entre as palavras begin e end e escreva então:

ShowMessage('Bem Vindo');

10
 Pascal para Delphi ®

ShowMessage é uma rotina do Delphi que mostra uma caixa de diálogo na tela, com uma mensagem
definida pelo programador. Note que após a linha de comando colocamos um ponto e vírgula. Isto é feito
para indicar ao compilador que a linha de comando terminou. Note também que o texto da mensagem está
entre aspas simples.

5) Aperte a tecla F9, para executar o exemplo. Aparece o seguinte quadro de mensagem:

6) Clique no botão OK, para fechar o quadro de mensagem.

7) Feche o formulário, para voltar ao ambiente do Delphi.

8) Se quiser salvar seu programa, selecione no menu File a opção Save Project As:

11
 Pascal para Delphi ®

9) Dê um nome para a unit, e clique no botão Salvar. Dê um nome para o projeto, e clique no botão
Salvar.

Note que a unit possui muito mais código do que a linha inserida por você:

unit Unit1;

interface

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

type
TForm1 = class(TForm)
procedure FormCreate(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;

var
Form1: TForm1;

implementation

{$R *.DFM}

procedure [Link] (Sender: TObject);

begin
ShowMessage('Bem Vindo');
end;

end.

12
 Pascal para Delphi ®

Como vimos, as demais linhas são necessárias para o funcionamento do programa, e são inseridas
automaticamente pelo Delphi, portanto, não se preocupe com elas.

Exemplo 2

Vamos criar agora um progama que escreva seu nome e sobrenome na tela. Podemos usar o mesmo
comando ShowMessage visto anteriormente:

1) Entre no Delphi.

2) Clique sobre o formulário apresentado, e, no Object Inspector, vá para a ficha Events, e dê um duplo
clique no evento onCreate.

3) Clique sobre a linha em branco entre as palavras begin e end e escreva então:

ShowMessage('Adelize Oliveira');

13
 Pascal para Delphi ®

5) Aperte a tecla F9, para executar o exemplo:

6) Volte para o ambiente do Delphi.

Adicionando Comentários ao Programa

Muitas vezes, ao escrevermos um programa, sentimos necessidade de comentar alguma linha de código,
seja para nos lembrarmos de nosso raciocínio posteriormente, seja para facilitar o entendimento do código
por parte de outros programadores.

O Pascal permite que você insira comentários em seu código, bastando para isso colocar seu comentário
entre chaves { }, ou entre os sinais (* e *).

O texto delimitado pelas chaves não será lido pelo compilador, servindo apenas como informação para o
programador.

Exemplo 3

O código abaixo ilustra o uso de comentários no código:

procedure [Link](Sender: TObject);

begin
{ Mostraremos uma mensagem}
ShowMessage('Adelize Oliveira');
(* A mensagem foi mostrada *);
end;

14
 Pascal para Delphi ®

Tipos de Dados

Um tipo de dado define uma região de valores que uma variável é capaz de armazenar, e também define
um conjunto de operações que as variáveis daquele tipo são capazes de realizar.

O Pascal oferece os seguintes tipos de dados::

Integer: inteiro. Ocupa somente 2 bytes de memória, e seu valor pode variar de -32.768 até 32.767.

Shortint: inteiro curto. Ocupa somente 1 byte de memória, e seu valor pode variar de -128 até 127.

Longint: inteiro longo. Ocupa 4 bytes de memória, e seu valor varia de - [Link] até
[Link].

Word: inteiro sem sinal. Ocupa 2 bytes da memória e seu valor varia de 0 até 65.535.

Byte: inteiro sem sinal. Ocupa apenas 1 byte da memória e seu valor varia de 0 até 255.

Real: número decimal. Ocupa 6 bytes da memória, e seu valor varia de 2.9E-39 até 1.7E+38, com 11 a 12
dígitos significativos.

Single: número decimal. Ocupa 4 bytes da memória, e seu valor varia de 1.5E-45 até 3.4E+38, com 7 a 8
dígitos significativos.

Double: número decimal . Ocupa 8 bytes da memória, e seu valor varia de 5.0E-324 até 1.7E+308, com
15 a 16 dígitos significativos.

Extended: número decimal. Ocupa 10 bytes da memória, e seu valor varia de 3.4E-4932 até 1.1E+4932,
com 19 a 20 dígitos significativos.

Comp: é um tipo real que ocupa 8 bytes da memória e que só armazena inteiros. Seu valor varia de -
2E+63 +1 até 2E+63 -1 com 19 a 20 dígitos significativos.

Char: assume caracteres do teclado como valores.

Boolean: assume apenas True (verdadeiro) e False (falso) como valores.

String: é formado por um conjunto de elementos do tipo Char.

O Delphi oferece também um outro tipo de dado, TDateTime, para manipular dados no formato de data e
hora.
15
 Pascal para Delphi ®

Variáveis

Variáveis são identificadores que mudam de valores de acordo com o programa.

Declarando Variáveis

Você precisa dar a uma variável tanto um nome quanto um tipo.

Siga as seguintes regras na criação de variáveis:

 os nomes de variáveis podem ter tamanho ilimitado, mas o compilador só lê os primeiros 63

caracteres;
 você pode utilizar letras e números, e o caracter de sublinhado _;
 os nomes das variáveis precisam começar com uma letra ou com o caracter de sublinhado _;
 cada variável deve ter um nome único, diferente das palavras reservadas do Pascal (veja lista a
seguir);
 não há diferença entre maiúsculas e minúsculas;
 não são permitidos espaços em branco no nome da variável.

Uma vez que você tenha determinado o nome da variável, deverá declarar seu tipo na seção var da unit:

unit Unit1;
interface
var
nome: string;
num: integer;
x,y: real;
implementation
end.

Como vimos acima, a declaração é feita definido-se um nome para a variável, seguido de um sinal de dois
pontos (:) e do tipo da variável, terminando finalmente com um ponto e vírgula (;).

Atribuindo Valores a Variáveis

Para atribuir valor a uma variável, você utiliza o operador de atribuição (:=). Por exemplo, para
atribuirmos o valor 4 a uma variável num, faríamos:

num := 4;

As variáveis declaradas na seção var podem ser utilizadas por todas as sub-rotinas e funções descritas no
programa, ou seja, são globais. Como veremos, você poderá criar variáveis locais, ou seja, variáveis que
só poderão ser utilizadas na procedure ou função onde são declaradas:

procedure Calculo;
var
A : integer;
begin
A := 4;
end;

16
 Pascal para Delphi ®

Exemplo 4

Vamos criar um programa que calcule o quadrado de uma determinado valor x, armazenando o resultado
na variável quadrado. Para isso:

1. Entre no Delphi.

2. Clique sobre o formulário apresentado, e, no Object Inspector, vá para a ficha Events, e dê um duplo
clique no evento onCreate.

3. Clique sobre a linha em branco entre as palavras begin e end e escreva então:

procedure [Link](Sender: TObject);

begin
x := 2;
quadrado := x * x;
ShowMessage(InttoStr(quadrado));
end;
Usamos a função de conversão InttoStr para converter um valor inteiro para string. As funções de
conversão serão vistas com mais detalhes posteriormente.

4. Role a unit até a cláusula var da seção implementation, e insira a declaração das variáveis:

var
Form1: TForm1;
x, quadrado : integer;

5. Aperte a tecla F9, para executar o exemplo.

6. Volte para o ambiente do Delphi.

Exemplo 5

O programa a seguir soma os valores de X e Y, armazenando o total na variável Conta, todas do tipo
integer. Após a soma, é mostrado na tela o resultado, usando-se o comando ShowMessage:

1. Entre no Delphi

2. Clique sobre o formulário apresentado, e, no Object Inspector, vá para a ficha Events, e dê um duplo
clique no evento onCreate.

3. Clique sobre a linha em branco entre as palavras begin e end e escreva então:

procedure [Link](Sender: TObject);

begin
X := 12;
Y := 13;
Conta := X + Y;
ShowMessage('O valor de Conta é '+ InttoStr(Conta));
end;

17
 Pascal para Delphi ®

4. Role a unit até a cláusula var da seção implementation, e insira a declaração das variáveis:

var
.....
Conta : integer;
X,Y : integer;

5. Aperte a tecla F9, para executar o exemplo.

6. Volte para o ambiente do Delphi.

Convertendo Dados

O Pascal oferece diversos comandos para a conversão de um tipo de dados em outro. Veja alguns:

Str

Converte um valor integer ou real para uma string, armazenando o resultado em uma variável.

Sintaxe:

Str(x, var s)

onde x é um número integer ou real, e var s é a variável do tipo string onde será armazenada a conversão.

Val

Converte uma string para um valor real.

Sintaxe:

Val (s: string, var v, var code)

onde s é a string a ser transformada, var v é a variável onde é armazenado o resultado da conversão, e var
code é a variável onde é armazenado o índice do caracter que tornou impossível a conversão, caso ela seja
impossível.

IntToStr

Converte um número do tipo integer para uma string contendo uma representação decimal daquele
número.

Sintaxe:

IntToStr(Valor: Longint)

onde Valor é o número a ser convertido. A função retorna uma string, contendo a representação decimal
daquele número.

FloatToStr

18
 Pascal para Delphi ®

Converte um número do tipo real, single, double ou extended em uma string.

Sintaxe:

FloatToStr(valor: extended)

onde valor é o número a ser convertido. A função retorna uma string, contendo a representação decimal
daquele número.

StrToInt

Converte uma string representando um número integer em um número.

Sintaxe:

StrToInt(s: string)

onde s é a string a ser convertida. A função retorna um valor Longint. Se a string não representa um
número válido, StrToInt retorna uma exceção.

StrToFloat

Converte uma string representando um número real, single, double ou extended em um número.

Sintaxe:

StrToFloat(s: string)

onde s é a string a ser convertida. A função retorna um valor extended. Se a string não representa um
número válido, StrToFloat retorna uma exceção.

Constantes

São identificadores que não alteram seu valor durante a execução do programa. Podem ser dos mesmos
tipos descritos para variáveis, e as regras descritas para criação dos nomes das variáveis devem ser
seguidas para a criação de constantes.

As constantes são declaradas na cláusula const:

unit Unit1;
interface
.....
const
num = 350;
nome = 'Pascal';
implementation
...
end.

Como vimos acima, a declaração de constantes é feita descrevendo seu nome, seguido de um sinal de
igual (=), seu valor e um ponto e vírgula (;).

19
 Pascal para Delphi ®

Note que:

 você usa o operador = para atribuir valores à constantes;

 para trabalhar com constantes do tipo string, você deverá colocar seu conteúdo entre aspas
simples.
 as demais constantes serão classificadas de acordo com o que foi digitado. Por exemplo, um
número 650000 é muito grande para ser do tipo integer, logo só pode ser do tipo longint.

Palavras Reservadas

As palavras abaixo são reservadas pelo Pascal, não podendo ser usadas para nomes de variáveis ou
constantes:

and as asm array begin

case class const constructor destructor

div do downto else end

except exports file finally for

function goto if implementation in

inherited inline initialization interface is

label library mod nil not

object of or packed procedure

program property raise record repeat

set shl shr string then

to try type unit until

uses var while with xor

Operadores e Expressões

Uma expressão pode ser uma simples constante ou variável, ou a combinação de variaveis e constantes
usando operadores.

Os operadores podem ser: aritméticos, relacionais, lógicos, e de string.

Operadores Aritméticos Função

+ Soma
- Diferença
* Multiplicação
/ Divisão
20
 Pascal para Delphi ®

^ Exponenciação
Div Divisão
mod Módulo

Operadores Relacionais Função

= Igual
< Menor
> Maior
<= Menor ou Igual
>= Maior ou Igual
<> Diferente

Operadores Lógicos Função

And E
Or Ou
Not Não
Xor ou exclusivo

Operadores de Strings Função

+ concatena strings

Exemplo 6

Vamos criar um programa, que tire a raiz quadrada de um número, multiplique-a por 3, converta o valor
em string e coloque o resultado na tela. Para isso, siga os seguintes passos:

1) Entre no Delphi.

2) Clique sobre o formulário apresentado, e, no Object Inspector, vá para a ficha Events, e dê um duplo
clique no evento onCreate.

3) Clique sobre a linha em branco entre as palavras begin e end e escreva então:

procedure [Link](Sender: TObject);

begin
quadrado := square(x);
mult := quadrado * 3;
str(mult, result);
ShowMessage('O valor é '+ InttoStr(result));
end;

21
 Pascal para Delphi ®

4) Role a unit até a cláusula var da seção implementation, e insira a declaração das variáveis:

var
.....
x, quadrado, mult : real;
result : string;

5) Aperte a tecla F9, para executar o exemplo.

6) Volte para o ambiente do Delphi.

Introdução a Procedures e Funções

Uma procedure ou uma função representa um conjunto de comandos que realizam determinada tarefa:

function CalculaSoma(num1, num2: integer): longint;

begin
CalculaSoma := num1 + num2;
end;

Você pode criar suas próprias procedures e funções, para organizar o código da aplicação de forma a
facilitar sua leitura e manutenção, ou mesmo para reaproveitar procedures e funções em outras aplicações.

A diferença principal entre procedures e funções é que funções retornam valores após serem processadas,
ao passo que procedures nada retornam.

Criando Procedures

Uma procedure é composta de duas partes:

 Um cabeçalho;
 Um bloco de código.

Criando o Cabeçalho da Procedure

O cabeçalho identifica a procedure e lista os parâmetros que a rotina usa, se usar. Uma procedure começa
com a palavra reservada procedure.
22
 Pascal para Delphi ®

procedure ValidaEntrada;

As procedures podem ter parâmetros, ou seja, dados que são passados para a procedure quando esta é
chamada.

Os parâmetros, ou argumentos, são listados entre parênteses. Cada parâmetro possui um identificador e
um tipo, e são separados entre si por um ponto e vírgula (;):

procedure ValidaEntrada(num: integer; nome: string);

No exemplo acima, a procedure possui dois parâmetros: num e nome. Ou seja, quando chamarmos a
procedure ValidaEntrada em nosso programa, teremos que fornecer para ela um número inteiro e uma
string.

Escrevendo o Corpo da Procedure

O corpo da procedure pode conter declarações de variáveis, constantes ou novos tipos de dados.

A parte dos comandos inicia com a palavra reservada begin e termina com a palavra reservada end.

procedure ValidaEntrada(num: integer; nome: string);

begin
....
end;

Declarando Variáveis e Constantes

Como vimos, você também pode declarar variáveis dentro de uma procedure, usando a palavra reservada
var:

procedure ValidaEntrada(num: integer; nome: string);

var
resultado : string;
dado : integer;

begin
....
end;

Neste caso, as variáveis declaradas serão locais, ou seja, só poderão ser utilizadas dentro da procedure. Se
quiser que suas varíáveis sejam globais, deve declará-las na seção interface, cláusula var da unit:

unit Unit1;

interface

var
23
 Pascal para Delphi ®

resultado : string;

implementation
...
end.

O mesmo raciocínio vale para as constantes. Você pode declará-las na seção const da procedure, e então
serão locais:

procedure ValidaEntrada(num: integer; nome: string);

const
pi = 3,14;

begin
....
end;

Se quiser que suas constantes sejam globais, deve declará-las na seção interface,cláusula const da unit, e
não da procedure.

Criando Funções

Uma função é composta de duas partes:

 Um cabeçalho;
 Um bloco de código.

Como vimos anteriormente, a diferença entre uma procedure e uma função é que a função retorna algum
valor, após ser executada.

Criando o Cabeçalho da Função

O cabeçalho identifica a função e lista os parâmetros que a rotina usa, se usar, assim como o tipo de dado
de retorno. Uma função começa com a palavra reservada function.

function ValidaEntrada : boolean;

As funções podem ter parâmetros, ou seja, dados que são passados para a função quando esta é chamada.

Os parâmetros, ou argumentos, são listados entre parênteses. Cada parâmetro possui um identificador e
um tipo, e são separados entre si por um ponto e vírgula (;):

function ValidaEntrada(num: integer; nome: string) : boolean;

24
 Pascal para Delphi ®

No exemplo acima, a função possui dois parâmetros: num e nome. Ou seja, quando chamarmos a
funçãoValidaEntrada em nosso programa, teremos que fornecer para ela um número inteiro e uma string.

Escrevendo o Corpo da Função

O corpo da função pode conter declarações de variáveis, constantes ou novos tipos de dados.

A parte dos comandos inicia com a palavra reservada begin e termina com a palavra reservada end.

functionValidaEntrada(num: integer; nome: string) : boolean;

begin
....
end;

Declarando Variáveis e Constantes

Como vimos, você também pode declarar variáveis dentro de uma função, usando a palavra reservada
var:

function ValidaEntrada(num: integer; nome: string): boolean;

var
resultado : string;
dado : integer;

begin
....
end;

Neste caso, as variáveis declaradas serão locais, ou seja, só poderão ser utilizadas dentro da fun Se quiser
que suas varíáveis sejam globais, deve declará-las na seção interface, cláusula var da unit:

unit Unit1;

interface

var
resultado : string;

implementation
...
end.

O mesmo raciocínio vale para as constantes. Você pode declará-las na seção const da função, e então
serão locais:

function ValidaEntrada(num: integer; nome: string): boolean;

const
pi = 3,14;
25
 Pascal para Delphi ®

begin
....
end;

Se quiser que suas constantes sejam globais, deve declará-las na seção interface,cláusula const da unit, e
não da função.

Retornando uma Função

Ao contrário das procedures, as funções possuem também um tipo para o valor de retorno. Este tipo é
especificado no final do cabeçalho, separado deste por um sinal de dois pontos (:):

function CalculaSoma(num1, num2: integer): longint;

Se estiver construindo uma função, o valor de retorno desta pode ser atribuido à uma variável com o
nome da função:

function CalculaSoma(num1, num2: integer): longint;

begin
CalculaSoma := num1 + num2;
end;

O Delphi também aceita que você atribua o retorno da função à variável Result:

functionalculaSoma(num1, num2: integer): longint;

begin
Result := num1 + num2;
end;

Posicionando a Procedure ou Função na Unit

Como vimos, antes de utilizar qualquer identificador em Pascal, é necessário declará-lo. Portanto, antes
de podermos usar uma procedure ou função é necessário declará-la. A declaração de uma procedure ou
função é posicionada após todas as cláusulas uses, var, const, e type da seção interface, e antes da seção
implementation:

unit Unit1;

interface
uses
....
type
...
const
...

26
 Pascal para Delphi ®

var
...

procedure ValidaEntrada(num:integer; nome: string);

implementation
....
end.

Já o corpo da procedure ou função deve ficar na seção implementation:

unit Unit1;

interface
...

procedure ValidaEntrada(num:integer; nome: string);

implementation
{$R *.DFM}

procedure ValidaEntrada(num:integer; nome: string);

begin
.....
end;

end.

Exemplo 7

A procedure abaixo calcula a diferença de duas variáveis:

procedure CalculaDiferenca;

var
num1, num2 : integer;
dif : integer;

begin
num1 := 10;
num2 := 2;
dif := num1 - num2;
end;

Criamos a procedure acima iniciando-a com a palavra reservada procedure. CalculaDiferenca é o nome
da procedure. Iniciamos então uma seção var, onde declaramos três variáveis locais à procedure, todas do
tipo integer: num1, num2 e dif.

Após a seção var, colocamos o corpo da procedure, entre as palavras reservadas begin e end. Atribuímos
valores para num1 e num2, e calculamos a diferença entre eles, atribuindo o resultado para a variável dif.

27
 Pascal para Delphi ®

Se você quiser utilizar o valor da variável dif em outro local, deveria criar uma função, ao invés de uma
procedure:

Function CalculaDiferenca : integer;

var
num1, num2 : integer;

begin
num1 := 10;
num2 := 2;
CalculaDiferenca := num1 - num2;
end;

Nesse caso, o retorno da função é dado através de uma variável CalculaDiferenca, que possui o mesmo
nome da função. Note que especificamos no cabeçalho da função que seu retorno é um dado do tipo
integer.

Se os valores de num1 e num2 forem fornecidos por outra procedure, você pode colocá-los como
parâmetros:

procedure CalculaDiferenca(num1,num2 : integer);

var
dif : integer;

begin
dif := num1 - num2;
end;

Veja como ficaria posicionada a procedure CalculaDiferenca dentro da unit Unit1. Para efeito de
ilustração, vamos supor que a variável dif é uma variável global:

unit Unit1;

interface
......

var
dif : integer;

procedure CalculaDiferenca;

implementation
{$R *.DFM}

procedure CalculaDiferenca;
var
num1, num2 : integer;

begin
num1 := 10;
num2 := 2;

28
 Pascal para Delphi ®

dif := num1 - num2;

end;

end.

<>

Chamando a Procedure ou Função

Para chamar a procedure ou função, basta digitar o nome da procedure ou função, seguida dos
parâmetros, caso haja.

Abaixo chamamos a função ValidaEntrada, passando dois argumentos:

begin
numero := StrToInt('1');
ValidaEntrada(numero, '2');
end.

Exemplo 8

A unit abaixo possui duas procedures, MostraResultado e CalculaDiferenca. A procedure

CalculaDiferenca calcula a diferenca entre dois valores, e a procedure MostraResultado mostra na tela
esta diferença. Quando o formulário é criado (ou seja, quando o evento onCreate ocorre), chamamos a
função MostraResultado:

unit Unit1;

interface

var
dif : integer;
resultado : string;

procedure CalculaDiferenca;
procedure MostraResultado;

implementation
{$R *.DFM}
procedure CalculaDiferenca;
var
num1, num2 : integer;
begin
num1 := 10;
num2 := 2;
dif := num1 - num2;
str(dif, resultado);
end;

procedure MostraResultado;
begin
CalculaDiferenca;
ShowMessage('A diferença é: '+ resultado);
29
 Pascal para Delphi ®

end;

procedure [Link](Sender: TObject);

begin
MostraResultado;
end;

end.

Como vimos, a procedure MostraResultado chama a procedure CalculaDiferenca. O valor armazenado na

variável dif, global, é então mostrado na tela. Preste atenção em dois pontos:

 Se a variável dif ou a variável resultado fossem declaradas na seção var da procedure

CalculaDiferenca, não poderíamos nos referir a elas na procedure MostraResultado.
 Como a procedure MostraResultado chama a procedure CalculaDiferenca, esta última deve ser
declarada primeiro. Isto porque, se você declarasse a procedure MostraResultado primeiro, o
compilador acusaria um erro, dizendo que há uma procedure sendo usada (CalculaDiferenca) sem
ser declarada.

Veja como ficaria a unit anterior se passássemos os valores de num1 e num2 como parâmetros, na
chamada da procedure CalculaDiferenca::

unit Unit1;

interface

var
dif : integer;
resultado : string;

procedure CalculaDiferenca(num1, num2 : integer);

procedure MostraResultado;

implementation
{$R *.DFM}
procedure CalculaDiferenca(num1, num2 : integer);

begin
dif := num1 - num2;
str(dif, resultado);
end;

procedure MostraResultado;
begin
CalculaDiferenca(10,2);
ShowMessage('A diferença é: '+ resultado);

end;

procedure [Link](Sender: TObject);

begin
MostraResultado;
end;
30
 Pascal para Delphi ®

end.

Se a procedure CalculaDiferenca fosse uma função, poderíamos utilizar seu retorno, e nosso programa
ficaria assim:

unit Unit1;

interface

var
resultado : string;

function CalculaDiferenca(num1,num2 : integer) : integer;

procedure MostraResultado;

implementation
{$R *.DFM}

function
CalculaDiferenca(num1, num2 : integer) : integer;
begin
CalculaDiferenca := num1 - num2;
end;

procedure MostraResultado;
begin
resultado :=InttoStr(CalculaDiferenca ( 10,2));
ShowMessage('A diferença é: '+ resultado);
end;

procedure [Link](Sender: TObject);

begin
MostraResultado;
end;

end.

Passagem de Parâmetros por Valor ou Referência

Os parâmetros (ou argumentos) dos procedimentos e das funções podem ser passados de duas forma: por
valor ou por referência.

Passagem de Parâmetros por Valor

A passagem de parâmetro por valor passa para a procedure apenas o valor atual da variável. Quando
acabarmos a procedure e voltarmos ao programa que a chamou, a variável passada como parâmetro ainda
terá o mesmo valor.

Passagem de Parâmetros por Referência

Já na passagem por referência, colocamos antes do parâmetro a palavra

var:
31
 Pascal para Delphi ®

procedure VerificaParametro(var num : integer);

Desta forma, podemos não só passar como parâmetro o valor original da variável, como também
modificar este valor dentro da procedure que a utiliza como parâmetro. Uma referencia da variável é
passada para a procedure.

Exemplo 9

O programa abaixo usa a passagem de parâmetro por valor:

unit Unit1;

inteface

var
Index : integer;

procedure VerificaParametro(num : integer);

implementation
{$R *.DFM}

procedure VerificaParametro(num : integer);

begin
num := 12;
end;

procedure [Link](Sender: TObject);

begin
Index := 1;
ShowMessage('O valor inicial de Index é '+ IntToStr(Index));
VerificaParametro(Index);
ShowMessage('Após a procedure, o valor de Index é ' +
IntToStr(Index));
end;

end.

Ou seja, quando chamamos a rotina VerificaParametro, passamos como parâmetro a variável Index, com
valor inicial de 1. Como a passagem é por valor, a variável Index continua com valor 1 quando a
procedure acaba, mesmo que dentro da procedure VerificaParametro mudemos o valor de num (que
representa a variável Index) para 12.

O resultado o programa acima é o seguinte:

O valor inicial de Index é 1

Após a procedure, o valor de Index é 1

Veja como ficaria o programa anterior se usássemos a passagem de parâmetro por referencia:

unit Unit1;

32
 Pascal para Delphi ®

inteface
var
Index : integer;

procedure
VerificaParametro(varnum : integer);

implementation
{$R *.DFM}

procedure VerificaParametro(varnum : integer);

begin
num := 12;
end;

procedure [Link](Sender: TObject);

begin
Index := 1;
ShowMessage('O valor inicial de Index é '+IntToStr(Index));
VerificaParametro(Index);
ShowMessage('Após a procedure, o valor de Index é ' +
IntToStr(Index));
end;

end.

Ou seja, quando chamamos a rotina VerificaParametro, passamos como parâmetro a variável Index, com
valor inicial de 1. Como a passagem é por referência, a variável Index muda de valor dentro da procedure,
já que mudamos o valor de num (que representa a variável Index) para 12.

O resultado o programa acima é o seguinte:

O valor inicial de Index é 1

Após a procedure, o valor de Index é 12

Visão Geral

Com um comando condicional, você poderá forçar o programa a executar um bloco de operações de
acordo com uma condição.

O Pascal possui dois grupos de comandos condicionais:

 If...then
 Case...of

33
 Pascal para Delphi ®

If ... then

Este comando condicional é utilizado quando precisamos avaliar uma determinada condição. Se esta for
verdadeira, executaremos determinado comando.

Sintaxe:

if expressão then
comando;

Outra sintaxe para o comando If...then inclui o uso do comando else:

Sintaxe:

if expressão then
comando1
else
comando2;

Ou seja, se expressão for verdadeira, executaremos a linha de comando1. Se for falsa, executaremos os
comandos posteriores ao else, ou seja, a linha de comando 2.

Note que a linha imediatamente anterior a palavra else não termina com um ponto e vírgula!

Quando o bloco de comandos a ser executado dentro de um if...then for muito extenso, você deve inseri-
los dentro de uma estrutura begin...end:

if expressão then
begin
bloco de comandos1;
end
else
begin
bloco de comandos2;
end;

Comandos Aninhados

Você pode aninhar um comando if...then dentro de um outro comando if...then:

if expressão then
begin
comando1;
if expressão2 then
comando 2;
end
else
comando3;

O Comando Exit

34
 Pascal para Delphi ®

Através do comando Exit você pode sair de um bloco de comandos limitado por begin...end, evitando que
as demais linhas após o comando Exit sejam avaliadas:

if expressão then
Exit;

O Comando GoTo

Este comando desvia o código para um determinado rótulo:

Sintaxe:

GoTo <rótulo>

Onde rótulo é um rótulo numérico definido na cláusula label da procedure:

unit Uni

interface
.....

implementation

procedure MinhaProcedure;
label
210;

begin
....
end;

end.

Exemplo 10

O programa abaixo mostrará uma frase na tela se a variável x for maior que a variável y:

unit Unit1;

interface

var
x, y : integer;

implementation
{$R *.DFM}
procedure [Link](Sender: TObject);
begin
x := 15;
y := 12;
if (x > y) then
ShowMessage('X é maior do que Y');
end;

35
 Pascal para Delphi ®

end.

O programa abaixo mostrará uma frase na tela se a variável x for maior que a variável y, e outra se x for
menor do que y:

unit Unit1;

interface

var
x, y : integer;

implementation
{$R *.DFM}
procedure [Link](Sender: TObject);
begin
x := 15;
y := 12;
if (x > y) then
ShowMessage('X é maior do que Y')
else
ShowMessage('Y é maior do que X');
end;

end.

O programa abaixo mostrará uma frase na tela se a soma da variável x for maior que 25, e outra se não
for:

unit Unit1;

interface

var
x, y, soma : integer;
resultado : string;

implementation
{$R *.DFM}

procedure [Link](Sender: TObject);

begin
x := 15;
y := 12;
if (x + y > 25) then
begin
soma := x + y;
str(soma, resultado);
ShowMessage('A soma é igual a '+resultado);
end
else
ShowMessage('A soma é menor que 25');

36
 Pascal para Delphi ®

end;
end.

O programa abaixo calcula a área de um quadrado. Se a área estiver entre 25 e 60 metros quadrados, a
área é suficiente, e o programa mostra uma mensagem na tela. Senão, o programa verifica qual a
metragem, e se for menor do que 10 metros quadrados, mostra uma mensagem avisando que a sala é
muito pequena:

unit Unit1;

interface

var
x, area : integer;
resultado : string;

implementation
{$R *.DFM}

procedure [Link](Sender: TObject);

begin
x := 6;
area := x * x;
if (area > 25) and (area < 60)then
begin
str(area, resultado);
ShowMessage('A área é suficiente!');
ShowMessage ('A área é de '+ resultado);
end
else
begin
if (area < 10) then
ShowMessage('A área é muito pequena!')
else
ShowMessage('Ainda há possibilidades!');
end;
end;
end.

O programa abaixo verifica o valor de uma variável, mostrando-a na tela somente se seu valor for
diferente de 1:

unit Unit1;

interface

var
x : integer;

procedure VerificaValor;

implementation
{$R *.DFM}
37
 Pascal para Delphi ®

procedure VerificaValor;
begin
x := 1;
if (x = 1) then
exit
else
begin
x := x + 3;
end;
ShowMessage('O valor de x foi acrescido de 3 unidades');
end;

procedure [Link](Sender: TObject);

begin
VerificaValor;
end;

end.

Ou seja, quando x for igual a 1, a mensagem não é mostrada, pois o comando Exit interrompe a execução
do bloco inserido entre o begin e o end da procedure.

O programa abaixo desvia o programa para o rótulo 1, se o valor da variável X for maior do que 10:

unit Unit1;

interface

var
x : integer;

implementation

{$R *.DFM}

produre [Link](Sender: TObject);

label
1;
begin
x := 20;
if x > 10 then
goto 1;
ShowMessage('O programa não foi para o label');
1: ShowMessage('O programa veio para cá');
end;

end.

Ou seja, se o valor de x for maior do que 10, o programa pula para a linha com o rótulo 1, definido na
seção label do programa.

Case ... of
38
 Pascal para Delphi ®

Este comando condicional permite a execução de comandos de acordo com o resultado de uma expressão
do tipo ordinal.

Sintaxe:

case expressão of
sequencias de constantes 1: comando 1;
sequencias de constantes 2: comando 2;
end;

As constantes da sequencia são separadas por vírgula. Você pode definir um intervalo de constantes,
usando dois pontos (..) entre elas:

case tecla of
'A'..'Z', 'a'..'z': ShowMessage('Letra');

Outra sintaxe para o comando Case...of inclui o uso do comando else:

case expressão of
constantes 1: comando 1;
constantes 2: comando 2;
else
comando 3;
end;

Neste caso, se o valor de expressão não for igual as constantes 1 ou iguais as constantes 2, o bloco de
comando 3 será executado.

Note que ao contrário do comando if...then...else, a linha anterior a palavra else termina com um ponto e
vírgula.

Quando o bloco de comandos a ser executado dentro de um case...of for muito extenso, você deve inserí-
los dentro de uma estrutura begin...end:

case expressão of
constantes 1:
begin
comandos 1;
end;

constantes 2:
begin
comandos 2;
end;
else
begin
comandos 3;
end;
end;

39
 Pascal para Delphi ®

Exemplo 11

A unit abaixo faz determinado cálculo de acordo com o valor de x:

unit Unit1;

interface

var
x, y : integer;

implementation

{$R *.DFM}

procedure [Link](Sender: TObject);

begin
x := 2;

case x of
1 : y := x + x;
2 : y := x * x;
3 : y := x div x;
end;

ShowMessage(InttoStr(y));
end;

end.

O programa abaixo avalia o valor da variável Tecla:

unit Unit1;

interface

var
tecla : char;

implementation

{$R *.DFM}

procedure [Link](Sender: TObject);

begin
tecla := 'a';

case tecla of
'A'..'Z', 'a'..'z':ShowMessage('Letra');
'0'..'9':ShowMessage('Número');
'+', '-', '*', '/':ShowMessage('Operador');
end;
end;

40
 Pascal para Delphi ®

end.

A unit abaixo faz determinado cálculo de acordo com o valor de x. Se este não foi igual a 1, 2 ou 3, os
valores são subtraídos:

unit Unit1;

interface

var
x, y : integer;

implementation

{$R *.DFM}

procedure [Link](Sender: TObject);

begin
x := 2;

case x of
1 : y := x + x;
2 : y := x * x;
3 : y := x div x;
else
y := x - x;
end;

ShowMessage(IntToStr(y));
end;

end.

O programa abaixo calcula o valor do salário de um funcionário, de acordo com seu código de função:

unit Unit1;

interface

var
codo : integer;
salario, desconto : real;

implementation

{$R *.DFM}

procedure [Link](Sender: TObject);

begin
Cod := 2;
desconto := 0;

41
 Pascal para Delphi ®

case Cod of
1 :
begin
salario := 1000;
desconto := salario * 0.2;
salario := salario-desconto;
end;

2:
begin
salario := 2000;
desconto := salario * 0.2;
salario := salario-desconto;
end;

3:
begin
salario := 3000;
desconto := salario *0.2;
salario := salario-desconto;
end;

else
ShowMessage('Código não existe!');
end;
ShowMessage('O valor do desconto é '+ FloatToStr(desconto));
end;

end.

Visão Geral

Os comandos de repetição repetem blocos de comando de acordo com determinada condição. Por
exemplo, se você precisa repetir uma soma enquanto o total não atende determinada condição, use
comandos interativos.

Entre os comandos de repetição oferecidos pelo Pascal temos:

 while...do
 for...do
 repeat...until

While ... do

Este comando repete um bloco de comando enquanto determinada condição for verdadeira.

42
 Pascal para Delphi ®

Sintaxe:

while expressão do
comando1;

Quando o bloco de comandos a ser executado dentro de um while...do for muito extenso, você deve
inseri-los dentro de uma estrutura begin...end:

while expressão do
begin
comando 1;
comando 2;
comando n;
end;

Interrompendo o Loop

Para interromper a repetição de um bloco de comandos dentro de uma estrutura while...do, use o comando
Break:

while expressão do
begin
comando1;
break;
end;

Exemplo 12

O programa abaixo multiplica os valores de dois números até que o total atinja o valor de 1000:

unit Unit1;

interface

var
x, total : integer

implementation

{$R *.DFM}

procedure [Link](Sender: TObject);

begin
total := 5;
x := 2;
while (total < 1000) do
total := total * x;
ShowMessage(IntToStr(total));
end;

end.

43
 Pascal para Delphi ®

O programa abaixo mostra na tela um aviso sobre a contagem sendo feita:

unit Unit1;

interface

var
Contador : integer;

implementation

{$R *.DFM}

procedure [Link](Sender: TObject);

begin
Contador := 4;

while Contador < 20 do

begin
ShowMessage('O valor de Contador é '+ IntToStr(Contador));
Contador := Contador + 2;
end;
end;

end.

Veja como ficaria o programa anterior se usássemos um comando break para interromper a contagem se o
valor da variável Contador atingisse 10:

unit Unit1;

interface

var
Contador : integer;

implementation

{$R *.DFM}

procedure [Link](Sender: TObject);

begin
Contador := 4;

while Contador < 20 do

begin
ShowMessage('O valor de Contador é '+ IntToStr(Contador));
Contador := Contador + 2;
if (Contador = 10) then
break;
end;
end;

end.
44
 Pascal para Delphi ®

For ... do

Com essa estrutura, você poderá repetir um bloco de comandos um número determinado de vêzes.

Sintaxe:

for variavel := expressão1 to expressão2 do

comando;

Ao invés da palavra to, você pode usar a palavra downto. Com downto, você parará no passo anterior a
expressão2:

for variavel := expressão1 downto expressão2 do

comando;

Quando o bloco de comandos a ser executado dentro de um for...do for muito extenso, você deve inseri-
los dentro de uma estrutura begin...end:

for variavel := expressão to expressão do

begin
comando 1;
comando 2;
end;

Interrompendo o Loop

Para interromper a repetição de um bloco de comandos dentro de uma estrutura for...do, use o comando
Break:

for variavel := expressão to expressão do

begin
comando1;
break;
end;

Exemplo 13

O programa abaixo mostra uma lista de números de 1 a 10:

unit Unit1;

interface

45
 Pascal para Delphi ®

var
Num : integer;

implementation

{$R *.DFM}

procedure [Link](Sender: TObject);

begin

for num:= 1 to 10 do
ShowMessage(InttoStr(num));
end;

end.

O programa abaixo recalcula a área de um quadrado, ao ampliarmos a sua área até 10 metros quadrados:

unit Unit1;

interface

var
area, x : integer;
resultado : string;

implementation

{$R *.DFM}

procedure [Link](Sender: TObject);

begin

for x:=1 to 10 do
begin
area := x * x;
str(area, resultado);
ShowMessage('A área do quadrado é igual a ' + resultado);
end;
end;

end.

Veja como ficaria o programa anterior se usássemos um comando break para interromper a contagem se o
valor da área atingisse 25:

unit Unit1;

interface

var
area, x : integer;

46
 Pascal para Delphi ®

resultado : string;

implementation

{$R *.DFM}

procedure [Link](Sender: TObject);

begin

for x:= 1 to 10 do
begin
area := x * x;
if (area = 25) then
break;
str(area, resultado);
ShowMessage('A área do quadrado é igual a ' + resultado);
end;
end;

end.

Repeat ... until

Este comando é usado para se executar um grupo de comandos repetidas vezes, até determinada condição.

Sintaxe:

repeat
comando 1;
until condição;

Quando o bloco de comandos a ser executado dentro de um repeat...until for muito extenso, você deve
inseri-los dentro de uma estrutura begin...end:

repeat
begin
comando 1;
comando 2;
comando n;
end;
until condição;

Interrompendo o Loop

Para interromper a repetição de um bloco de comandos dentro de uma estrutura repeat...until, use o
comando Break:

repeat
begin
comando1;
47
 Pascal para Delphi ®

break;
end;
until condição;

Exemplo 14

O programa abaixo multiplica os valores de dois números até que o total atinja o valor de 1000:

unit Unit1;

interface

var
x, total : integer;

implementation

{$R *.DFM}

procedure [Link](Sender: TObject);

begin
total := 5;
x := 2;
repeat
total := total * x;
until (total < 1000);
ShowMessage(IntToStr(total));
end;

end.

O programa abaixo mostra na tela um aviso sobre a contagem sendo feita:

unit Unit1;

interface

var
Contador : integer;

implementation

{$R *.DFM}

procedure [Link](Sender: TObject);

begin

Contador := 4;
repeat
begin
ShowMessage(IntToStr(contador));
Contador := Contador + 2;
end;
48
 Pascal para Delphi ®

until Contador > 20;

end;

end.

Veja como ficaria o programa anterior se usássemos um comando break para interromper a contagem se o
valor da variável Contador atingisse 10:

unit Unit1;

interface

var
Contador : integer;

implementation

{$R *.DFM}

procedure [Link](Sender: TObject);

begin
Contador := 4;
repeat
begin
ShowMessage(IntToStr(contador));
Contador := Contador + 2;
if (Contador = 10) then
break;
end;
until Contador > 20;
end;

end.

Visão Geral

O Pascal oferece inúmeras funções e procedures pré-construídas para manipulação de strings.

Com elas você poderá, por exemplo, extrair parte de uma string, verificar seu comprimento, convertê-la
para número, etc.

Funções de Manipulação de Strings

Concat
49
 Pascal para Delphi ®

Esta função junta duas ou mais strings, formando uma só:

Sintaxe:

Concat(s1 [, s2,..., sn]: String) : string;

Onde s1, s2...sn são strings a serem concatenadas.

Exemplo:

var
S: String;
begin
S := Concat('ABC', 'DEF');
end.

À variável S será atribuído o valor ABCDEF.

Copy

Esta função permite que você isole um substring do meio de uma string.

Sintaxe:

Copy (expr,início,num) : string;

onde expr é uma expressão do tipo string, início é a localização do primeiro caracter a extrair, e num o
número de caracteres a serem extraídos. Esta função retorna uma string.

Exemplo:

Copy ('palavra',2,3)

retorna ala.

Length

Esta função determina a largura do string.

Sintaxe:

Length(s: string) : integer;

onde s é uma variável do tipo string. A função retorna um valor integer.

Exemplo:

s := 'palavra';
Length (s);

retorna 7.

50
 Pascal para Delphi ®

Pos

Esta função permite que se procure um determinado substring em um string, mesmo sem saber se este
substring será encontrado.

Sintaxe:

Pos (s: string, d: string) : integer;

onde s é a substring a ser encontrada dentro da string d. A função pos retorna um valor integer, referente
ao índice da primeira letr da substring. Se a substring não for encontrada, retorna-se 0.

Exemplo:

palavra := 'felicidade'
numero := Pos ('idade', palavra);

retorna 6.

UpperCase

Esta função substitui todas as letras minúsculas de uma string por letras maiúsculas.

Sintaxe:

UpperCase (s: string) : string;

onde s é a string que terá as letras convertidas. Esta função retorna uma string igual a s, só que com todas
as letras maiúsculas.

Exemplo:

s := 'palavra';
UpperCase(s);

retorna PALAVRA.

LowerCase

Esta função substitui todas as letras maiúsculas de uma string por letras minúsculas.

Sintaxe:

LowerCase (s: string) : string;

onde s é a string que terá as letras convertidas. Esta função retorna uma string igual a s, só que com todas
as letras maiúsculas transformadas em minúsculas.

Exemplo:

s := 'Palavra';

51
 Pascal para Delphi ®

LowerCase(s);

retorna palavra.

IntToStr

Converte um número do tipo integer para uma string contendo uma representação decimal daquele
número.

Sintaxe:

IntToStr(Valor: Longint) : string;

onde Valor é o número a ser convertido. A função retorna uma string, contendo a representação decimal
daquele número.

Exemplo:

s : string;
num := 10;
s := IntToStr(num);

retorna '10'.

FloatToStr

Converte um número do tipo real, single, double ou extended em uma string.

Sintaxe:

FloatToStr(valor: extended) : string;

onde valor é o número a ser convertido. A função retorna uma string, contendo a representação decimal
daquele número.

StrToInt

Converte uma string representando um número integer em um número.

Sintaxe:

StrToInt(s: string) : longint;

onde s é a string a ser convertida. A função retorna um valor Longint. Se a string não representa um
número válido, StrToInt retorna uma exceção.

Exemplo:

num: integer;
s := '10';
num := StrToInt (s);

52
 Pascal para Delphi ®

retorna 10.

StrToFloat

Converte uma string representando um número real, single, double ou extended em um número.

Sintaxe:

StrToFloat(s: string) : extended;

onde s é a string a ser convertida. A função retorna um valor extended. Se a string não representa um
número válido, StrToFloat retorna uma exceção

Procedures de Manipulação de String

Delete

Esta procedure remove uma substring de uma string.

Sintaxe:

Delete(palavra, índice, quant);

Onde palavra é a string que terá parte extraída, índice é a partir de qual letra será iniciada a extração, e
quant é a quantidade de letras a ser extraída.

Exemplo:

s := 'Florianópolis';
Delete(s,1,8)

A variável s terá agora o valor ''polis'.

Insert

Esta procedure insere uma substring em uma string.

Sintaxe:

Insert(origem, palavra, indice);

Onde origem é a string a ser inserida, palavra é a string em cujo interior inseriremos outra string, e índice
é a partir de qual letra será iniciada a inserção.

Exemplo:

s := 'Florianópolis';
Insert('Eu amo ',s,1)

A variável s terá agora o valor 'Eu amo Florianópolis'.

53
 Pascal para Delphi ®

Str

Esta sub-rotina converte um valor integer ou real para uma string, armazenando o resultado em uma
variável.

Sintaxe:

Str(x, var s);

onde x é um número integer ou real, e var s é a variável do tipo string onde será armazenada a conversão.

Exemplo:

s: string;
x := 10;
str(x,s);

tem como resultado o armazenamento de 10 em s.

Val

Esta sub-rotina retira o valor numérico de um string.

Sintaxe:

Val (s: string, var v, var code);

onde s é a string a ser transformada, var v é a variável onde é armazenado o resultado da conversão, e var
code é a variável onde é arm o índice do caracter que tornou impossível a conversão.

Exemplo:

v,code: integer;
s := '10';
val(s,v,code);

tem como resultado o armazenamento de 10 em v.

Visão Geral - Parei Aqui.

O Pascal oferece uma série de rotinas aritméticas para serem usadas em cálculos matemáticos.

54
 Pascal para Delphi ®

Com elas você pode, por exemplo, extrair a raiz quadrada de um elemento, seu valor absoluto, seu
logarítmo natural, etc.

Principais Rotinas Matemáticas

Abs

Retorna o valor absoluto do argumento.

Sintaxe:

Abs(Variavel);

Onde Variavel é a variável de onde será retirado o valor absoluto.

Exemplo:

var
valor : real;
begin
valor := Abs(-3.5);

O valor de retorno será igual a: 3.5.

ArcTan

Retorna a tangente do argumento.

Sintaxe:

ArcTan(Variavel);

Onde Variavel é a variável de onde será retirado o valor da tangente.

Exemplo:

var
num : extended;
begin
num := arctan(Pi);

O valor de retorno será o valor da tangente de PI.

Cos

Retorna o cosseno do argumento.

Sintaxe:

Cos(Variavel);

55
 Pascal para Delphi ®

Onde Variavel é a variável de onde será retirado o valor do coseno.

Exemplo:

var
numero : extended;
begin
numero := cos(Pi);

O valor de retorno será o valor do coseno de PI.

Exp

Retorna o exponencial do argumento.

Sintaxe:

Exp(Valor);

Onde Valor é o valor a ser calculado o exponencial.

Exemplo:

var
x : real;
begin
x := exp(1.0);

O valor de retorno será: 2,71828182845905

Frac

Retorna a parte fracionária do argumento.

Sintaxe:

Frac(Valor);

Onde Valor é o valor de onde deve ser retirada a parte fracionária.

Exemplo:

var
fracao : real;
begin
fracao := Frac(12.32);

O Valor de retorno será: 0.32.

Int

56
 Pascal para Delphi ®

Retorna a parte inteira do argumento.

Sintaxe:

Int(Valor);

Onde Valor é o valor de onde deve ser obtida a parte inteira do argumento.

Exemplo:

var
inteiro : real;
begin
inteiro := Int(19.82);

O Valor de retorno será: 19.

Ln

Retorna o logarítmo natural do argumento.

Sintaxe:

Ln(Variavel);

Onde Variavel é a variável que contém o valor a ser calculado.

Exemplo:

var
loga : real;
begin
loga := Ln(1.82);

O valor de retorno será aproximadamente: 0,598836501088704

Pi

Retorna o valor de Pi.

Sintaxe:

Variavel := Pi;

Onde Variavel é uma variável onde ficará armazenado o valor de PI.

Exemplo:

var
valorpi : real;
begin

57
 Pascal para Delphi ®

valorpi := Pi;

O valor de retorno será aproximadamente: 3,14159265358979

Sin

Retorna o seno do argumento.

Sintaxe:

Sin(Variavel);

Onde Variavel é uma variável que contém o valor a ser calculado.

Exemplo:

var
seno : real;
begin
seno := Sin(45.27);

O Valor de retorno será aproximadamente: 0,96019594136273

Sqr

Retorna o quadrado do argumento.

Sintaxe:

Sqr(Valor);

Onde Valor é o valor que deve ser elevado ao quadrado.

Exemplo:

var
quadrado: real;
begin
quadrado:= Sqr(11);

O Valor de retorno será: 121.

Sqrt

Retorna a raiz quadrada do argumento.

Sintaxe:

Sqrt(Valor);

58
 Pascal para Delphi ®

Onde Valor é o valor que deve ser calculada a raíz quadrada.

Exemplo:

var
raiz : real;
begin
raiz := Sqrt(144);

O Valor de retorno será: 12.

Exemplo 15

O programa abaixo realiza alguns cálculos em cima do valor de uma variável:

unit Unit1;

interface

var
x, y, z, w : real;

implementation

{$R *.DFM}

procedure [Link](Sender: TObject);

begin
x := 16;
y := abs(x);
ShowMessage(FloattoStr(y));
z := sqrt(x);
ShowMessage(FloattoStr(z));
w := ln(x);
ShowMessage(FloattoStr(w));
end;

end.

Visão Geral
59
 Pascal para Delphi ®

Além dos dados próprios do Pascal, o usuário pode criar novos tipos de dados:

 array;
 enumerado;
 intervalo;
 set;
 record.

Arrays

Um array (ou vetor) é uma coleção ordenada de um tipo de dado, com cada elemento da coleção
especificado por sua posição numérica dentro da coleção.

Um array é criado na seção var do programa, e usa a seguinte sintaxe:

var
num : array [1..10] of integer;

A variável num se refere a uma lista de 10 variáveis do tipo integer, cada uma com um número de indice
de 1 a 10.

Nos referimos a cada item do array através do seu índice entre colchetes [ ]. Por exemplo:

num[5] := 250;

Exemplo 16

A unit abaixo escreve na tela uma lista dos anos dos carros armazenados em um array:

unit Unit1;
interface
var
Index : integer;
Automoveis : array[1..12] of integer;
implementation
{$R *.DFM}
procedure [Link](Sender: TObject);
begin
for Index := 1 to 12 do
begin
Automoveis[Index] := Index + 1980;
ShowMessage('O automóvel de número ' + InttoStr(Index) + '
tem o valor ' + InttoStr(Automoveis[ Index]));
end;
ShowMessage('Fim do Programa!');
end;
end.

Inicialmente, a variável Index será igual a 1. Atribuiremos ao primeiro item do array, Automoveis[1], o
valor de 1980+1, ou seja, 1981. Escreveremos então na tela a frase O automóvel de número 1 tem o valor
de 1981.
60
 Pascal para Delphi ®

Repetiremos a estrutura for, sendo que agora a variável Index tem o valor de 2 (a estrutura for se
autoincrementa de uma unidade). Atribuiremos ao segundo item do array, Automoveis[2], o valor de
1980+2, ou seja, 1982. Escreveremos então na tela a frase O automóvel de número 1 tem o valor de 1982.
E assim sucessivamente.

Exemplo 17

Vamos criar um programa que liste a seguinte tabela na tela:

Ano

1980 1981 1982

----------------------------------------------------------

Motor 0 (Gasolina) 1900 1901 1902

1 (Alcool) 1901 1902 1903

unit Unit1;
interface
var
Automoveis : array[0..1,1980..1982] of integer;
Ano, Motor : integer;
implementation
{$R *.DFM}
procedure [Link](Sender: TObject);
begin
for Ano := 1980 to 1982 do
begin
for Motor := 0 to 1 do
begin
Automoveis[Motor,Ano] := Ano - 80 + Motor;
ShowMessage('O valor do carro com motor ' + InttoStr(motor) + '
do ano '+ InttoStr(ano) + ' é de ' + InttoStr( Automoveis[Motor,
Ano]));
end;
end;
end;
end.

Inicialmente, atribuímos à variável Ano o valor 1980, dentro da primeira estrutura for. Na segunda
estrutura for, atribuímos à variável Motor o valor 0. Atribuimos ao item Automoveis[0,1980] do vetor
Automoveis o valor 1900, correspondente a conta 1980 - 80 + 0. Escrevemos então na tela a frase O carro
com motor 0 do ano 1980 possui valor de 1900.

Acrescentamos 1 à variável Motor, e voltamos à segunda estrutura for. Atribuimos ao item

Automoveis[1,1980] do vetor Automoveis o valor 1901, correspondente a conta 1980 - 80 + 1.
Escrevemos então na tela a frase O carro com motor 1 do ano 1980 possui valor de 1901.

61
 Pascal para Delphi ®

Acabamos então a segunda estrutura for, e voltamos para a primeira, sendo que agora a variável Ano está
acrescentada de uma unidade, valendo então 1981. E voltamos ao raciocínio do parágrafo anterior.

Strings

Strings são arrays do tipo char. Quando você declara uma variável do tipo string, pode determinar o
número de caracteres que esta contém:

var
nome : string[30];

Na realidade os arrays de caracter são 1 byte maiores do que o tamanho especificado na string, porque a
primeira posição da string é um byte que contém o tamanho da string.

Registros

Registros (records) são coleções de dados aos quais sua aplicação pode ser referir como um todo. Por
exemplo, você poderia criar um registro de nome Empregado, que contivesse os dados deste: último
nome, primeiro nome, ano do emprego. Cada um destes dados é também conhecido como campo do
registro.

Os registros não são declarados na seção var do programa, e sim na seção type, usando a seguinte sintaxe:

type
Nome_Registro = record
Dado1 : tipo_dado;
Dado2 : tipo_dado;
.....
end;

Após criar o tipo de dado registro, você deve criar uma variável do tipo do registro criado. Isto é feito na
seção var do programa, usando-se a sintaxe tradicional:

var
nome_variavel : nome_registro

Você pode acessar cada campo ou se referir ao registro como um todo, usando a seguinte sintaxe:

variavel_tipo_registro.campo

Exemplo 18

Vamos criar um registro de nome Empregado, que contenha os dados deste: último nome, primeiro nome,
ano do emprego.

type
Empregado = Record
UltimoNome :string[20];
PrimeiroNome : string[15];
AnoEmprego : string[4];

62
 Pascal para Delphi ®

end;

Todos os dados são do tipo string, já que conterão texto. Estamos estabelecendo também o número total
de caracteres que cada string poderá conter.

Após criarmos o registro Empregado, vamos criar uma variável chamada Empreg1, do tipo Empregado:

type
Empregado = Record
UltimoNome :string[20];
PrimeiroNome : string[15];
AnoEmprego : string[4];
end;

var
Empreg1 : Empregado;

Vamos escrever na tela os valores dos dados de nosso primeiro empregado,

unit Unit1;
interface
type
Empregado = Record
UltimoNome :string[20];
PrimeiroNome : string[15];
AnoEmprego : string[4];
end;
var
Empreg1 : Empregado;
implementation
{$R *.DFM}
procedure [Link](Sender: TObject);
begin
[Link] := 'Prado';
[Link] := 'Alyssa';
[Link] := '1996';
ShowMessage([Link]);
ShowMessage(Empreg1. PrimeiroNome);
ShowMessage([Link]);
end;
end.

Tipo Enumerado

Um dado do tipo enumerado (enumerated type) representa uma lista de valores. Na declaração do tipo de
dado, são listados os valores possíveis. Por exemplo:

type
TDias = (Segunda, Terça,Quarta);
63
 Pascal para Delphi ®

Para criar uma variável do tipo acima, faríamos:

var
DiadaSemana : TDias;

Na lista, cada item corresponde a um valor inteiro, começando por 0.

Um item na lista de um tipo enumerado na verdade é um identificador. Logo, você não pode criar uma
variável com este nome. No exemplo acima, não poderia criar uma variável com o nome Segunda.

Tipo Set

Um conjunto (set) é uma coleção de elementos de um tipo que precisa ser byte, boolean, char, enumerado
ou intervalo. Por exemplo:

type
TVogais = set of char;

Para criar uma variável do tipo acima:

var
vogal : TVogais;
begin
texto := 'A';
Vogal := ['A' , 'E', 'I', 'O', 'U'];
if texto in vogal then
Writeln('OK')
else
Writeln('Tente de Novo');
end;

Use o operador in para verificar se um caracter é membro de um conjunto de elementos.

Tipo Intervalo

Uma estrutura de dados do tipo intervalo (subrange type) contém uma região de valores do tipo integer,
boolean, char ou enumerado. São úteis quando você quer limitar o valor que uma variável deve ter.

Para criar um intervalo, especifique o valor mínimo e o valor máximo, com dois pontos (..) entre eles. Por
exemplo:

type
TLetraValida = `A' .. ` F' ;

Para criar uma variável do tipo acima:

var
Letra : TLetraValida;

Para que a verificação de região seja feita, você deve utilizar a diretiva {$R+} no código da aplicação.

64
 Pascal para Delphi ®

Tipos de Arquivos

Para tornar seu programa mais útil, você precisará de um meio para armazenar de forma permanente os
dados, e recuperá-los posteriormente. Isto é feito através de arquivos. O Pascal suporta tanto arquivos
texto quanto arquivos binários.

Arquivos Texto

Nos arquivos texto, os dados são representados como caracteres do conjunto ASCII. Cada linha é
encerrada por um retorno de carro. Com este formato, as linhas podem variar de comprimento.

Arquivos Binários

Os arquivos binários armazenam os dados em uma representação binária compactada. Existem arquivos
binários tipificados e não-tipificados. Arquivos tipificados são arquivos binários que só armazenam dados
de um único tipo. Arquivos não-tipificados são arquivos binários que armazenam os dados em sequencia
de bytes sem tipo.

Trabalhando com Arquivos Texto

Os arquivos texto, apesar de facilmente manipuláveis, apresentam duas limitações:

Nem todos os caracteres podem ser armazenados em um arquivo texto (somente aqueles que podem ser
exibidos na tela ou impressora, incluindo os caracteres de retorno de carro, de avanço de linha e
tabulação);

Não podem ser acessados aleatoriamente, ou seja, a leitura dos dados deve ser sempre feita a partir do
início do arquivo.

Variáveis do Tipo Arquivo

Para acessar um arquivo texto você deve declarar uma variável do tipo arquivo. Para declarar variáveis de
arquivo texto, faça:

var
nome_da_variável : Text;

A atribuição do nome do arquivo à variável é feita através do comando Assign ou AssignFile (específico
do Delphi):
65
 Pascal para Delphi ®

AssignFile(variável, 'nome_do_arquivo_extensão');

Após atribuir o arquivo a uma variável, você pode utilizar as rotinas de manipulação de arquivo para
abrir, ler e gravar no arquivo.

Manipulando Arquivos Texto

Entre as rotinas de manipulação de arquivos texto, temos:

Append

Abre um arquivo existente para a entrada de novos dados no final do arquivo.

Sintaxe:

Append(Variavel);

Onde Variavel é uma variável do tipo TextFile.

Exemplo:

var
arq: TextFile;
begin
if [Link] then
begin
AssignFile(f, [Link]);
AssignFile(f);
Append(f);
Writeln(f, 'Texto a ser inserido no arquivo.');
Flush(f);
CloseFile(f);
end;
end;

O código acima abre um arquivo texto e insere nele uma nova string.

CloseFile

Fecha um arquivo.

Sintaxe:

CloseFile(Variavel);

Onde Variavel é uma variável do tipo TextFile.

Exemplo:

66
 Pascal para Delphi ®

var
F: TextFile;
S: string;
begin
if [Link] then
begin
AssignFile(F, [Link]);
Reset(F);
Readln(F, S);
[Link] := S;
CloseFile(F);
end;
end;

O código acima abre um arquivo inexistente.

EOF

Retorna o status de fim de arquivo.

Sintaxe:

Eof(Variavel);

Onde Variavel é uma variável do tipo TextFile.

Exemplo:

var
arq : TextFile;
nome : String;
begin
AssignFile(arq);
Reset(arq);
While not eof(arq) do
begin
Read(nome);
end;
CloseFile(arq);
end.

O código acima lê um nome enquanto não chegar ao fim do arquivo.

EOLN

Retorna o status de fim de linha de um arquivo texto

Sintaxe:

Eoln(Variavel);

Onde Variavel é uma variável do tipo Text.

67
 Pascal para Delphi ®

Exemplo:

Writeln(Eoln);

O código acima escreve uma linha no fim do arquivo.

Erase

Apaga um arquivo externo.

Sintaxe:

Erase(Variavel);

Onde Variavel é uma variável do tipo TextFile.

Exemplo:

var
F: Textfile;
begin
[Link] := 'Delete File';
if [Link] then
begin
AssignFile(F, [Link]);
try
Reset(F);
if MessageDlg('Deletar ' + [Link] + '?',
mtConfirmation, [mbYes, mbNo], 0) = mrYes then
begin
CloseFile(F);
Erase(F);
end;
except
on EInOutError do
MessageDlg('Erro de I/O.', mtError, [mbOk], 0);
end;
end;
end;

O código acima simplesmente apaga um arquivo texto.

FileSize

Retorna o tamanho corrente de um arquivo.

Sintaxe:

FileSize(Variavel);

Onde Variavel é uma variável do tipo Integer.

68
 Pascal para Delphi ®

Exemplo:

var
f: file of Byte;
size : Longint;
S: string;
y: integer;
begin
AssignFile(f);
Reset(f);
size := FileSize(f);
S := 'Tamanho dos arquivos em bytes: ' + IntToStr(size);
y := 10;
[Link](5, y, S);
y := y + [Link](S) + 5;
S := 'Verificando o restante do arquivo...';
[Link](5, y, S);
y := y + [Link](S) + 5;
Seek(f,size div 2);
S := 'Posição ' + IntToStr(FilePos(f));
[Link](5, y, S);
CloseFile(f);
end;

O código acima pega e exibe o tamanho de um arquivo.

Flush

Esvazia o buffer de um arquivo texto aberto para output.

Sintaxe:

Flush(Variavel);

Onde Variavel é uma variável do tipo TextFile;

Exemplo:

var
f: TextFile;
begin
if [Link] then
begin
AssignFile(f, [Link]);
Append(f);
Writeln(f, 'Texto');
Flush(f);
CloseFile(f);
end;
end;

O código acima esvazia o buffer de um arquivo.

69
 Pascal para Delphi ®

IOResult

Retorna o status da útima operação I/O realizada.

Sintaxe:

IOResult : Integer;

Exemplo:

var
F: file of Byte;
begin
if [Link] then
begin
AssignFile(F, [Link]);
{$I-}
Reset(F);
{$I+}
if IOResult = 0 then
MessageDlg('Tamanho do arquivo em bytes: ' +
IntToStr(FileSize(F)),
mtInformation, [mbOk], 0);
else
MessageDlg('Erro ao acessar arquivo ', mtWarning, [mbOk],
0);
end;
end;

O código acima retorna o status da última operação I/O.

Read

Lê um elemento de dado de um arquivo.

Sintaxe:

Read(Variavel);

Onde Variavel é a variável que irá conter os dados.

Exemplo:

var
nome : String;
idade : Integer:
begin
read(nome);
read(idade);
end;

O código acima faz a leitura de um nome e de uma idade qualquer.

70
 Pascal para Delphi ®

Readln

Lê uma linha de dados de um arquivo.

Sintaxe:

Readln(Variavel);

Onde Variavel é a variável onde ficará armazenado um determinado valor.

Exemplo:

var
arq : TextFile;
nome : String;
idade : Integer;
begin
AssignFile(arq',Nome_do_Arquivo');
Reset(arq);
While not eof(arq) do
Begin
readln(nome);
readln(idade);
end;
CloseFile(arq);
end;

O código acima lê o nomes e idades armazenados em um arquivo texto.

Rename

Renomeia um arquivo externo.

Sintaxe:

Rename(Variavel);

Onde Variavel é uma variável do tipo Pchar.

Exemplo:

var
f : file;
begin
[Link] := 'Escolha o arquivo... ';
if [Link] then
begin
[Link] := 'Renomear para...';
if [Link] then
begin
71
 Pascal para Delphi ®

AssignFile(f, [Link]);
[Link](5, 10, 'Renomeando ' + [Link]
+ ' para ' +
[Link]);
Rename(f, [Link]);
end;
end;
end;

O código acima muda o nome de um arquivo já existente.

Reset

Abre um arquivo existente.

Sintaxe:

Reset(Variavel);

Onde Variavel é uma variável do tipo File;

Exemplo:

var
F: file;
begin
{$I-}
AssignFile(F, FileName);
FileMode := 0;
Reset(F);
CloseFile(F);
{$I+}
FileExists := (IOResult = 0) and (FileName <> '');
end;
begin
if FileExists(ParamStr(1)) then
[Link](10, 10, 'Arquivo Encontrado')
else
[Link](10, 10, 'Arquivo não Encontrado');
end;

O código acima abre um arquivo existente, caso ele não exista é exibida uma mensagem.

Rewrite

Cria e abre um novo arquivo.

Sintaxe:

Rewrite(Variavel);

Onde Variavel é uma variável do tipo TextFile.

72
 Pascal para Delphi ®

Exemplo:

var
F: TextFile;
begin
AssignFile(F, '[Link]');
Rewrite(F);
Writeln(F, 'Texto');
CloseFile(F);
end;

O código acima cria um arquivo com o nome de "[Link]".

SeekEof

Retorna o status de fim de arquivo de um arquivo.

Sintaxe:

SeekEof(Variavel);

Onde Variavel é uma variável do tipo Booleano.

Exemplo:

var
f : [Link];
i, j, Y : Integer;
begin
AssignFile(f,'[Link]');
Rewrite(f);
Writeln(f,'1 2 3 4 ');
Writeln(f,'5 6 7 8 ');
Reset(f);
Y := 5;
while not SeekEof(f) do
begin
Readln;
Read(f,j);
[Link](5, Y, IntToStr(j));
Y := Y + [Link](IntToStr(j)) + 5;
end;
end;

O código acima lê um determinado arquivo enquanto a condição não for satisfeita.

SeekEoln

Retorna o status de fim de linha de um arquivo.

Sintaxe:

73
 Pascal para Delphi ®

SeekEoln(Variavel);

Onde Variavel é uma variável do tipo Booleano.

Exemplo:

var
f : [Link];
i, j, Y : Integer;
begin
AssignFile(f,'[Link]');
Rewrite(f);
Writeln(f,'1 2 3 4 ');
Writeln(f,'5 6 7 8 ');
Reset(f);
Y := 5;
while not SeekEof(f) do
begin
if SeekEoln(f) then
Readln;
Read(f,j);
[Link](5, Y, IntToStr(j));
Y := Y + [Link](IntToStr(j)) + 5;
end;
end;

SetTextBuf

Atribui um buffer de I/O para um arquivo texto.

Sintaxe:

SetTextBuf(Variaveis);

Onde Variaveis são variáveis do tipo TextFile, Char, e vetor.

Exemplo:

var
F, FTwo: [Link];
Ch: Char;
Buf: array[1..4096] of Char; {buffer de 4K}
begin
if [Link] then
begin
AssignFile(F, [Link]);
[Link](F, Buf);
Reset(F);
AssignFile(FTwo, '[Link]');
Rewrite(FTwo);
while not Eof(f) do
begin
74
 Pascal para Delphi ®

Read(F, Ch);
Write(FTwo, Ch);
end;
[Link](F);
[Link](FTwo);
end;
end;

O código acima atribuirá o buffer de I/O para um arquivo texto.

Write

Grava um ou mais elementos de dados para o arquivo.

Sintaxe:

Write(arq'Texto');

Onde arq é o arquivo onde queremos escrever o "Texto".

Exemplo:

var
arq : TextFile;
begin
AssignFile(arq);
Reset(arq);
Write(arq,'Texto Qualquer');
CloseFile(arq);

O código acima armazenará em um determinado arquivo a string desejada.

Writeln

Grava uma linha de dados de um arquivo.

Sintaxe:

Writeln(arq'Texto');

Onde arq é o arquivo onde queremos escrever o "Texto".

Exemplo:

var
arq : TextFile;
begin
AssignFile(arq);
Reset(arq);
Writeln(arq,'Texto Qualquer 01');
Writeln(arq,'Texto Qualquer 02');
CloseFile(arq);
75
 Pascal para Delphi ®

O código acima escreve duas linhas em um determinado arquivo texto.

Exemplo 19

A unit abaixo atribui o arquivo [Link] à variável MeuTexto:

unit Unit1;
interface
var
MeuTexto : TextFile;
implementation
{$R *.DFM}
procedure [Link](Sender: TObject);
begin
AssingFile(MeuTexto,'[Link]');
end;
end.

O exemplo abaixo abre um arquivo texto ([Link], que tem que existir) e copia seus dados para um
segundo arquivo ([Link], que é criado, caso não exista):

unit Unit1;
interface
var
F1, F2: TextFile;
Ch: Char;
implementation
{$R *.DFM}
procedure [Link](Sender: TObject);
begin
AssignFile(F1, '[Link]');
Reset(F1);
AssignFile(F2, '[Link]');
Rewrite(F2);
while not Eof(F1) do
begin
Read(F1, Ch);
Write(F2, Ch);
end;
CloseFile(F2);
CloseFile(F1);
end;
end.

O exemplo abaixo coloca a primeira linha de um arquivo texto na tela:

unit Unit1;
interface
var
F: TextFile;
S: String;
implementation
76
 Pascal para Delphi ®

{$R *.DFM}
procedure [Link](Sender: TObject);
begin
AssignFile(F, 'c:\[Link]');
<> Reset(F);
Readln(F, S);
ShowMessage(S);
CloseFile(F);
end;
end.

O exemplo abaixo acrescenta o texto "texto incluído" no final de um arquivo texto:

unit Unit1;
interface
var
F: TextFile;
implementation
{$R *.DFM}
procedure [Link](Sender: TObject);
begin
AssignFile(F, '[Link]');
Append(F);
Writeln(F, ' texto incluido');
CloseFile(F);
end;

end.

Trabalhando com Arquivos Binários

Para acessar um arquivo binário você deve declarar uma variável do tipo arquivo.

Para declarar variáveis de arquivo binário tipificado, faça:

var
nome_da_variável : FILE OF tipo_de_dado;

Para declarar variáveis de arquivo binário não-tipificado, faça:

var
nome_da_variável : FILE;

A atribuição do nome do arquivo à variável é feita através do comando Assign ou AssignFile:

AssignFile(variável, 'nome_do_arquivo_extensão');

Após estas tarefas, você pode utilizar as rotinas de manipulação de arquivo para abrir, ler e gravar no
arquivo.

Comandos de Manipulação de Arquivos Binários

77
 Pascal para Delphi ®

Entre as rotinas de manipulação de arquivos binários, temos:

AssignFile

Atribui o nome de um arquivo externo a uma variável de arquivo.

Sintaxe:

AssignFile(Variavel);

Onde Variavel é uma variável do tipo TextFile.

Exemplo:

var
F: TextFile;
S: string;
begin
if [Link] then
begin
AssignFile(F, [Link]);
Reset(F);
Readln(F, S);
CloseFile(F);
end;
end;

O código acima abre um arquivo lê uma string e depois é finalizado.

CloseFile

Fecha um arquivo aberto.

Sintaxe:

CloseFile(Variavel);

Onde Variavel é uma variável do tipo TextFile.

Exemplo:

var
arq : TextFile;
begin
If [Link] Then
begin
AssignFile(arq, [Link]);
Reset(arq);
CloseFile(arq);
end;
end;

78
 Pascal para Delphi ®

O código acima simplesmente abre e fecha um arquivo texto sem ao menos modificá-lo.

EOF

Retorna o status de fim de arquivo.

Sintaxe:

Eof(Variavel);

Onde Variavel é uma variável do tipo TextFile.

Exemplo:

var
arq : TextFile;
nome : String;
begin
AssignFile(arq);
Reset(arq);
While not eof(arq) do
begin
Read(nome);
end;
CloseFile(arq);
end.

O código acima lê um nome enquanto não chegar ao fim do arquivo.

Erase

Apaga um arquivo externo.

Sintaxe:

Erase(Variavel);

Onde Variavel é uma variável do tipo TextFile.

Exemplo:

var
F: Textfile;
begin
[Link] := 'Delete File';
if [Link] then
begin
AssignFile(F, [Link]);
try
Reset(F);
if MessageDlg('Deletar ' + [Link] + '?',
mtConfirmation, [mbYes, mbNo], 0) = mrYes then
79
 Pascal para Delphi ®

begin
CloseFile(F);
Erase(F);
end;
except
on EInOutError do
MessageDlg('Erro de I/O.', mtError, [mbOk], 0);
end;
end;
end;

O código acima simplesmente apaga um arquivo.

FilePos

Retorna a posição corrente de um arquivo.

Sintaxe:

FilePos(Variavel);

Onde Variavel é uma variável do tipo Longint.

Exemplo:

var
f: file of Byte;
size : Longint;
S: string;
y: integer;
begin
if [Link] then
begin
AssignFile(f, [Link]);
Reset(f);
size := FileSize(f);
S := 'Tamanho do arquivo em bytes: ' + IntToStr(size);
y := 10;
[Link](5, y, S);
y := y + [Link](S) + 5;
S := 'Localizando restante do arquivo...';
[Link](5, y, S);
y := y + [Link](S) + 5;
Seek(f,size div 2);
S := 'A posição é ' + IntToStr(FilePos(f));
[Link](5, y, S);
CloseFile(f);
end;
end;

O código acima retorna a posição corrente de um arquivo.

80
 Pascal para Delphi ®

FileSize

Retorna o tamanho corrente de um arquivo.

Sintaxe:

FileSize(Variavel);

Onde Variavel é uma variável do tipo Integer.

Exemplo:

var
f: file of Byte;
size : Longint;
S: string;
y: integer;
begin
AssignFile(f);
Reset(f);
size := FileSize(f);
S := 'Tamanho dos arquivos em bytes: ' + IntToStr(size);
y := 10;
[Link](5, y, S);
y := y + [Link](S) + 5;
S := 'Verificando o restante do arquivo...';
[Link](5, y, S);
y := y + [Link](S) + 5;
Seek(f,size div 2);
S := 'Posição ' + IntToStr(FilePos(f));
[Link](5, y, S);
CloseFile(f);
end;

O código acima pega e exibe o tamanho de um arquivo.

IOResult

Retorna o status da útima operação I/O realizada.

Sintaxe:

IOResult : Integer;

Exemplo:

var
F: file of Byte;
begin
if [Link] then
begin
AssignFile(F, [Link]);
81
 Pascal para Delphi ®

{$I-}
Reset(F);
{$I+}
if IOResult = 0 then
MessageDlg('Tamanho do arquivo em bytes: ' +
IntToStr(FileSize(F)),
mtInformation, [mbOk], 0);
else
MessageDlg('Erro ao acessar arquivo ', mtWarning, [mbOk],
0);
end;
end;

O código acima retorna o status da última operação I/O.

Read

Lê um elemento de dado de um arquivo.

Sintaxe:

Read(Variavel);

Onde Variavel é a variável que irá conter os dados.

Exemplo:

var
nome : String;
idade : Integer:
begin
read(nome);
read(idade);
end;

O código acima faz a leitura de um nome e de uma idade qualquer.

Rename

Renomeia um arquivo externo.

Sintaxe:

Rename(Variavel);

Onde Variavel é uma variável do tipo Pchar.

Exemplo:

var
f : file;
begin
82
 Pascal para Delphi ®

[Link] := 'Escolha o arquivo... ';

if [Link] then
begin
[Link] := 'Renomear para...';
if [Link] then
begin
AssignFile(f, [Link]);
[Link](5, 10, 'Renomeando ' + [Link]
+ ' to ' +
[Link]);
Rename(f, [Link]);
end;
end;
end;

O código acima muda o nome de um arquivo já existente.

Reset

Abre um arquivo existente.

Sintaxe:

Reset(Variavel);

Onde Variavel é uma variável do tipo File;

Exemplo:

var
F: file;
begin
{$I-}
AssignFile(F, FileName);
FileMode := 0;
Reset(F);
CloseFile(F);
{$I+}
FileExists := (IOResult = 0) and (FileName <> '');
end;
begin
if FileExists(ParamStr(1)) then
[Link](10, 10, 'Arquivo Encontrado')
else
[Link](10, 10, 'Arquivo não Encontrado');
end;

O código acima abre um arquivo existente, caso ele não exista é exibida uma mensagem.

Rewrite

Cria e abre um novo arquivo.

83
 Pascal para Delphi ®

Sintaxe:

Rewrite(Variavel);

Onde Variavel é uma variável do tipo TextFile.

Exemplo:

var
F: TextFile;
begin
AssignFile(F, '[Link]');
Rewrite(F);
Writeln(F, 'Texto');
CloseFile(F);
end;

O código acima cria um arquivo com o nome de "[Link]".

Seek

Move a posição corrente do arquivo até um "componente" especificado.

Sintaxe:

Seek(Variavel);

Onde Variavel é uma variável do tipo Longint;

var
f: file of Byte;
size : Longint;
S: string;
y: integer;
begin
AssignFile(f);
Reset(f);
size := FileSize(f);
S := 'Tamanho dos arquivos em bytes: ' + IntToStr(size);
y := 10;
[Link](5, y, S);
y := y + [Link](S) + 5;
S := 'Verificando o restante do arquivo...';
[Link](5, y, S);
y := y + [Link](S) + 5;
Seek(f,size div 2);
S := 'Posição ' + IntToStr(FilePos(f));
[Link](5, y, S);
CloseFile(f);
end;

O código acima pega e exibe o tamanho de um arquivo.

84
 Pascal para Delphi ®

Truncate

Trunca o arquivo na posição corrente.

Sintaxe:

Truncate(Variavel);

Onde Variavel é uma variável de arquivo exceto TextFile.

Exemplo:

var
f: file of Integer;
i,j: Integer;
begin
AssignFile(f,'[Link]');
Rewrite(f);
for i := 1 to 6 do
Write(f,i);
Writeln('Arquivo antes de ser truncado:');
Reset(f);
while not Eof(f) do
begin
Read(f,i);
Writeln(i);
end;
Reset(f);
for i := 1 to 3 do
Read(f,j);
Truncate(f);
Writeln;
Writeln('Arquivo depois de ser truncado:');
Reset(f);
while not Eof(f) do
begin
Read(f,i);
Writeln(i);
end;
CloseFile(f);
Erase(f);
end;

O código acima trunca os arquivos na posição corrente.

Write

Grava um ou mais elementos de dados para o arquivo.

Sintaxe:

Write(arq'Texto');
85
 Pascal para Delphi ®

Onde arq é o arquivo onde queremos escrever o "Texto".

Exemplo:

var
arq : TextFile;
begin
AssignFile(arq);
Reset(arq);
Write(arq,'Texto Qualquer');
CloseFile(arq);

O código acima armazenará em um determinado arquivo a string desejada.

Exemplo 20

Veja abaixo a declaração de uma variável do tipo arquivo, e sua atribuição:

var
MeuArq : FILE OF integer;
begin
AssingFile(MeuArq, `[Link]');
end;

O programa abaixo abre um arquivo, verifica seu tamanho, e vai até a metade deste:

unit Unit1;
interface
var
f: file of Byte;
tamanho : Longint;
S: String;
y: integer;
implementation
{$R *.DFM}
procedure [Link](Sender: TObject);
begin
AssignFile(f, '[Link]');
Reset(f);
tamanho := FileSize(f);
ShowMessage('Tamanho do Arquivo em Bytes é ' +
IntToStr(tamanho));
Seek(f,tamanho div 2);
ShowMessage('A posição é agora ' + IntToStr(FilePos(f)));
CloseFile(f);
end;
end.

Manipulando Arquivos Não-Tipados

Entre as rotinas de manipulação de arquivos binários não tipados temos:

86
 Pascal para Delphi ®

BlockRead

Lê um ou mais blocos de dados de um arquivo.

Sintaxe:

BlockRead(Variaveis);

Onde Variaveis são variáveis do tipo Integer, file e char.

Exemplo:

var
FromF, ToF: file;
NumRead, NumWritten: Integer;
Buf: array[1..2048] of Char; {buffer de 2K}
begin
if [Link] then
begin
AssignFile(FromF, [Link]);
Reset(FromF, 1);
if [Link] then
begin
AssignFile(ToF, [Link]);
Rewrite(ToF, 1);
[Link](10, 10, 'Copiando ' +
IntToStr(FileSize(FromF))+ ' bytes...');
repeat
BlockRead(FromF, Buf, SizeOf(Buf), NumRead);
BlockWrite(ToF, Buf, NumRead, NumWritten);
until (NumRead = 0) or (NumWritten <> NumRead);
CloseFile(FromF);
CloseFile(ToF);
end;
end;
end;

O código acima lê um bloco de dados de 2K.

BlockWrite

Escreve um ou mais bloco de dados em um arquivo

Sintaxe:

BlockRead(Variaveis);

Onde Variaveis são variáveis do tipo Integer, file e char.

Exemplo:

var
87
 Pascal para Delphi ®

FromF, ToF: file;

NumRead, NumWritten: Integer;
Buf: array[1..4096] of Char; {buffer de 4K}
begin
if [Link] then
begin
AssignFile(FromF, [Link]);
Reset(FromF, 1);
if [Link] then
begin
AssignFile(ToF, [Link]);
Rewrite(ToF, 1);
[Link](10, 10, 'Copiando ' +
IntToStr(FileSize(FromF))+ ' bytes...');
repeat
BlockRead(FromF, Buf, SizeOf(Buf), NumRead);
BlockWrite(ToF, Buf, NumRead, NumWritten);
until (NumRead = 0) or (NumWritten <> NumRead);
CloseFile(FromF);
CloseFile(ToF);
end;
end;
end;

No código acima a funcão BlockWrite grava 4K no arquivo..

Rotinas de Gerenciamento de Arquivos

O Pascal oferece inúmeras rotinas para gerenciamento de arquivos. Através destas rotinas, você pode
criar, abrir ou apagar um arquivo, converter datas e extrair dados sobre um determinado arquivo.

ChangeFileExt

Muda a extensão do arquivo.

Sintaxe:

ChangeFileExt(Variavel);

Onde Variavel é uma variável do tipo String.

Exemplo:

INIFileName := ChangeFileExt(ParamStr(0), '.INI');

O código acima muda a extensão de um arquivo para a extensão .INI.

DateTimeToFileDate

Converte a data do formato Delphi para o formato DOS.

Sintaxe:
88
 Pascal para Delphi ®

DateTimeToFileDate(Variavel);

Onde Variavel é uma variável do tipo DateTime.

Exemplo:

var
tempo : DateTime;
begin
DateTimeToFileDate(tempo);

O código acima converte a variável tempo para o formato DOS.

DeleteFile

Remove um arquivo.

Sintaxe:

DeleteFile(Constante);

Onde Constante é uma constante que contém o nome do arquivo.

Exemplo:

if FileExists(FileName) then
if MsgBox('Você deseja realmente deletar o arquivo ' +
ExtractFileName(FileName)
+ '?'), []) = IDYes then DeleteFile(FileName);

O código acima apaga um determinado arquivo.

DiskFree

Retorna a quantidade de espaço em disco livre.

Sintaxe:

DiskFree(Variaveis);

Onde Variaveis são variáveis do tipo String e Integer.

Exemplo:

var
S: string;
AmtFree: integer;
Total: integer;
begin
AmtFree := DiskFree(0);
Total := DiskSize(0);

89
 Pascal para Delphi ®

S := IntToStr(AmtFree div Total) + 'total de espaço livre em

disco: ' (AmtFree div 1024) + ' Kbytes livres. ';
[Link](10, 10, S);
end;

O código acima exibe a quantidade de espaço em disco.

ExpandFileName

Retorna a string contendo o path e nome do arquivo.

Sintaxe:

ExpandFileName(Variavel);

Onde Variavel é uma variável do tipo String.

Exemplo:

MyFileName := ExpandFileName(MyFileName);

O código acima exibe o caminho completo do arquivo.

ExtractFileName

Retorna somente o nome do arquivo.

Sintaxe:

ExtractFileName(Constante);

Onde Constante é uma constante que contém o caminho e nome do arquivo.

Exemplo:

FileName := ExtractFileName(FileName);

O código acima exibe somente o nome do arquivo.

ExtractFileExt

Retorna somente a extensão do arquivo.

ExtractFileExt(Constante);

Onde Constante é uma constante que contém o caminho e nome do arquivo.

Exemplo:

FileName := ExtractFileName(FileName);

90
 Pascal para Delphi ®

O código acima exibe somente a extensão do arquivo.

ExtractFilePath

Retorna o path do arquivo especificado.

Sintaxe:

ExtractFilePath(Constante);

Onde Constante é uma constante que contém o caminho e nome do arquivo.

Exemplo:

FileName := ExtractFilePath(FileName);

O código acima exibe somente o caminho do arquivo.

FileAge

Retorna a idade do arquivo.

Sintaxe:

FileAge(Constante);

Onde constante é uma constante que possui a localização do arquivo.

Exemplo:

FileAge(idade);

O código acima exibe a idade de um arquivo, mas para que isso possa funcionar, você precisa converter a
variável para TDateTime.

FileCreate

Cria um arquivo com o nome especificado.

Sintaxe:

FileCreate(Constante);

Onde Constante é uma constante que especifica o nome do arquivo.

Exemplo:

MyFileHandle := FileCreate('[Link]');

O código acima cria um arquivo com o nome de "[Link]".

91
 Pascal para Delphi ®

FileClose

Fecha o arquivo especificado.

Sintaxe:

FileClose(Constante);

Onde Constante é uma constante que contém a localização do arquivo.

Exemplo:

FileClose(arq);

O código acima fecha um determinado arquivo.

FileExists

Retorna True se o arquivo existe.

Sintaxe:

FileExists(Constante);

Onde constante é uma constante que identifica o arquivo.

Exemplo:

if FileExists(FileName) then
if MsgBox('Do you really want to delete ' +
ExtractFileName(FileName)
+ '?'), []) = IDYes then
ShowMessage('Arquivo Encontrado');

O código acima verifica a existência de um arquivo.

FileGetAttr

Retorna atributos do arquivo.

Sintaxe:

GetFileAttr(Constante);

Onde Constante é uma constante de identificação de arquivo.

Exemplo:

GetFileAttr(arq);

O código acima retorna os atributos de um determinado arquivo.

92
 Pascal para Delphi ®

FileRead

Lê de um arquivo específico.

Sintaxe:

FileRead(Variaveis);

Onde Variaveis são variáveis do tipo inteiro.

Exemplo:

ActualRead := FileRead(MyFileHandle, Buffer, SizeOf(Buffer));

O código acima lê um determinado número de bytes de um arquivo.

FileSearch

Procura através de diretórios por um arquivo especificado.

Sintaxe:

FileSearch(Constante,ListadeDiretorios);

Onde Constante é uma constante que identifica o arquivo e ListadeDiretorios é uma lista de diretórios em
que deve ser feita a procura do arquivo.

Exemplo:

FoundIt := FileSearch('[Link]',
MyAppDir+'\';'+WinDir+';'+WinDir+'\SYSTEM');

O código acima procura o arquivo [Link] em vários diretórios.

FileSeek

Muda a posição corrente do arquivo.

Sintaxe:

FileSeek(Variaveis);

Onde Variaveis são variáveis do tipo Integer.

Exemplo:

if FileSeek(MyFileHandle,0,2) = HFILE_ERROR then

HandleFileError
else
AppendStuff;

93
 Pascal para Delphi ®

O código acima muda a posição corrente do arquivo.

FileSetAttr

Estabelece atributos do arquivo.

Sintaxe:

FileSetAttr(Constantes);

Onde Constantes são constantes de definição do arquivo.

Exemplo:

FileSetAttr(arquivo,1);

O código acima estabelece os atributos de um determinado arquivo.

FileSetDate

Estabelece a data e hora do arquivo.

Sintaxe:

FileSetDate(Parametros);

Onde Parametros são os parâmetros da função.

Exemplo:

function FileSetDate(Handle: Integer; Age: Integer): Integer;

O código acima estabelece a data e hora de um determinado arquivo.

FileOpen

Abre um arquivo especificado.

Sintaxe:

FileOpen(Constante, Variavel);

Onde Constante é a constante que define o nome do arquivo, e Variavel é a variável que especifica o
valor de retorno.

Exemplo:

procedure OpenForShare(const FileName: String);

var
FileHandle : Integer;
begin

94
 Pascal para Delphi ®

FileHandle := FileOpen(FileName, fmOpenWrite or

fmShareDenyNone);
if FileHandle > 0 then
[Arquivo Válido}
else
[Erro ao Abrir: FileHandle = erro]
end;

O código acima abre um determinado arquivo.

FileWrite

Grava em um arquivo especificado.

Sintaxe:

FileWrite(Parametros)Integer;

Onde Parametros são os parâmetros da função.

Exemplo:

function FileWrite(Handle: Integer; const Buffer; Count: Integer):

Integer;

O código acima grava em um determinado número de bytes em um arquivo.

FindClose

Termina uma sequencia de FindFirst/FindNext.

Sintaxe:

FindClose(Variavel);

Onde Variavel é uma variável do tipo TSearchRec.

Exemplo:

var
SearchRec: TSearchRec;
begin
FindClose(SearchRec);
end;

O código acima localliza finaliza uma seqüência FindFirst/FindNext.

FindFirst

Pesquisa no diretório por um arquivo específico.

95
 Pascal para Delphi ®

Sintaxe:

FindFirst(Parametros): Integer;

Onde Parametros são os parâmetros da função.

Exemplo:

FindFirst('c:\Windows\*.*', faAnyFile, SearchRec);

[Link] := [Link] + ' tem ' + IntToStr([Link])
+ ' bytes ';

O código acima localiza todos os arquivos do diretório Windows.

FindNext

Retorna a próxima entrada que combina com o nome e atributos.

Sintaxe:

FindNext(Variavel): Integer;

Onde Variavel é uma variável do tipo TSearchRec.

Exemplo:

if (FindNext(SearchRec) = 0) then
[Link] := [Link] + ' tem ' +
IntToStr([Link]) + ' bytes ';

O código acima procura outro arquivo.

RenameFile

Renomeia um arquivo.

Sintaxe:

RenameFile(Constantes);

Onde Constantes são as constantes que contém o nome atual do arquivo e no novo nome.

Exemplo:

if not RenameFile('[Link]','[Link]') then

ErrorMsg('Erro ao renomear arquivo!');

O código acima muda o nome do arquivo [Link] para

Exemplo 21

96
 Pascal para Delphi ®

O programa abaixo apaga um arquivo especificado, se este existir:

unit Unit1;
interface
....
implementation
{$R *.DFM}
procedure [Link](Sender: TObject);
begin
if FileExists('[Link]') then
begin
ShowMessage('O arquivo '+ ExtractFileName( '[Link]') + ' será
apagado!');
DeleteFile('[Link]');
end;
end;
end.

Outras Rotinas de Manipulação de Arquivos

GetDir

Retorna o diretório corrente do drive especificado.

Sintaxe:

GetDir(Variavel);

Onde Variavel é uma variável do tipo String;

Exemplo:

var
s : string;
begin
GetDir(0,s); { 0 = Drive Corrente}
MessageDlg('Drive e diretório corrente: ' + s, mtInformation,
[mbOk] , 0);
end;

O código acima exibe o nome do drive e diretório corrente.

MkDir

Cria um novo subdiretório no path especificado.

Sintaxe:

MkDir(Variavel);

Onde Variavel é uma variável do tipo String.

97
 Pascal para Delphi ®

Exemplo:

begin
{$I-}
MkDir([Link]);
if IOResult <> 0 then
MessageDlg('Não é possível criar diretório', mtWarning,
[mbOk], 0)
else
MessageDlg('Novo diretório criado', mtInformation, [mbOk],
0);
end;

O código acima cria um novo diretório.

ChDir

Muda o diretório corrente para o path especificado.

Sintaxe:

ChDir(Variavel);

Onde Variavel é uma variável do tipo String.

Exemplo:

begin
{$I-}
ChDir([Link]);
if IOResult <> 0 then
MessageDlg('Diretório não encontrado', mtWarning, [mbOk], 0);
end;

O código acima muda o diretório corrente.

RmDir

Deleta um subdiretório vazio.

Sintaxe:

RmDir(Variavel);

Onde Variavel é uma variável do tipo String.

Exemplo:

begin
{$I-}
RmDir([Link]);
if IOResult <> 0 then
98
 Pascal para Delphi ®

MessageDlg('Não é possível remover diretório', mtWarning,

[mbOk], 0)
else
MessageDlg('Diretório removido', mtInformation, [mbOk], 0);
end;

O código acima deleta um diretório vazio.

Exemplo 22

O programa abaixo cria um diretório chamado MeuDiretorio:

unit Unit1;
interface
....
implementation
{$R *.DFM}
procedure [Link](Sender: TObject);
begin
MkDir('c:\MeuDiretorio');
if IOResult <> 0 then
ShowMessage('Não foi possível criar o diretório!')
else
ShowMessage('Diretório criado com sucesso!');
end;
end.

Imprimindo Arquivos

Para imprimir arquivos, utilize o comando AssignPrn.

Sintaxe:

procedure AssignPrn(var F: Text; Device, Driver, Port: PChar);

Este comando atribui à variável F a impressora. Se Device for nil, Driver e Port são ignoradas, e o
comando AssignPrn mandará o texto para a impressora default.

Após a atribuição, você deve utilizar o comando Rewrite. Assim, toda vez que a aplicação enviar dados
para F, os dados são enviados para a impressora.

Como o comando AssignPrn pertence à unit Printers, você deve acrescentar esta unit à cláusula uses da
seção interface de sua unit.

Exemplo 23

O exemplo abaixo imprime uma frase na impressora default:

unit Unit1;
interface
uses
.........., Printers;
99
 Pascal para Delphi ®

var
Arq1: TextFile;
implementation
{$R *.DFM}
procedure [Link](Sender: TObject);
begin
Arq1 := 'c:\[Link]';
AssignPrn(Arq1);
Rewrite(Arq1);
Writeln(Arq1, 'Imprima este texto');
CloseFile(Arq1);
end;
end.

Objetos

Usamos o termo objeto para representar uma determinada entidade do mundo real.

Exemplos de objetos são:

 Coisas (um livro, uma estante)

 Funções (Vendedor, Cliente, etc)
 Eventos
 Interações
 Lugares

O conceito de objetos baseia-se no princípio de abstração. Através da abstração, podemos dividir um

determinado problema em partes, para estudá-las separadamente. Na metodologia orientada, dividiremos
o problema em objetos.

É importante ressaltar que a metodologia estruturada também utilizava o princípio da abstração, mas sua
ênfase era na procura dos processos que envolviam o problema, e não nos objetos que o compunham.

Observe que tivemos o cuidado de colocar o artigo na frente de cada objeto, pois um objeto representa um
elemento apenas, uma determinada entidade. No entanto, um objeto pode ser uma entidade composta,
como uma estante (composta de livros, prateleiras, titulo, assunto, indice, etc). Em geral a maioria dos
objetos são realmente compostos, pois sempre podemos dividi-lo em partes menores até chegarmos a
elementos realmente atômicos (indivisíveis).

Um sistema seria então um grande objeto composto de outros objetos, formando um mecanismo.

O Sistema de Gerenciamento de Biblioteca

100
 Pascal para Delphi ®

Para entendermos melhor os conceitos ligados a orientação a objetos, vamos utilizar como exemplo um
sistema de Gerenciamento de Biblioteca, cujo objetivo é administrar as publicações (livros e revistas) de
uma biblioteca fictícia e seus usuários, assim como as movimentações realizadas pelos usuários
(empréstimos e devoluções).

No Sistema de Gerenciamento de Biblioteca, teríamos os seguintes objetos:

 publicações;
 usuários;
 movimentações.

Atributos ou Propriedades

Representam as características do objeto. Por exemplo, o objeto caneta possui as características tamanho,
cor, tipo de escrita. São seus atributos.

Os atributos, ou sejam as características dos objetos, podem ser fixos ou variáveis. O estado de um objeto
é o valor de determinado atributo em um dado instante. Por exemplo, uma estante em um determinado
momento pode estar vazia. Logo após, colocam-se alguns livros nela, modificando seu estado para uma
estante com livros.

Um evento corresponde a um estímulo externo, que pode provocar a transição de um estado para outro, ou
seja, pode modificar as propriedades de determinado objeto.

No Sistema de Gerenciamento de Biblioteca, o objeto publicações teria como atributos (ou seja,
características) identificador, editora, título, tipo (se é livro ou revista), e presença (se está na biblioteca
ou não). O objeto usuários teria como atributos identificador, nome, endereço, e usufruto (se está com
uma publicação ou não). O objeto movimentações teria como atributos data, identificador do usuário,
identificador da publicação, e tipo (empréstimo ou devolução).

Note que os atributos usufruto, do objeto usuário, e presença, do objeto publicações, podem mudar de
valor de acordo com um evento. Por exemplo, se o usuário pegar uma publicação emprestada, dando
origem a um evento, o atributo usufruto passa para Sim, indicando que o usuário agora possui um livro
emprestado, e o atributo presença passa para Não, indicando que a publicação não está mais na biblioteca.
Ou seja, estes atributos sofrem uma transição, uma mudança de estado devido a um evento..

Serviços ou Métodos

São as funções que operam sobre o objeto. Por exemplo, com o objeto caneta podemos escrever,
desenhar, presentear. São as funções oferecidas pelo objeto caneta.

101
 Pascal para Delphi ®

Quando um objeto executa um serviço (uma função), dizemos que ele apresenta um determinado
comportamento, ou seja, uma reação. O comportamento do objeto será resultado da ação efetuada sobre
ele, e da função que esta ação chamou. Por exemplo, tanto o rádio quanto a TV possuem um botão para
ligá-los. Quando apertamos este botão (ou seja, efetuamos uma ação sobre este objeto), o comportamento
apresentado por ambos é diferente, já que o serviço (função) chamado por esta ação é diferente: ligar o
rádio significa emitir som; ligar a TV significa emitir som e imagem.

Um evento, ou seja, um estímulo externo, também pode estimular o objeto a executar determinado
serviço.

No Sistema de Gerenciamento de Biblioteca, todos os objetos poderiam ser cadastrados, ou seja,

inseridos, alterados, excluídos e consultados:

Classes

Uma classe representa um conjunto de objetos que possuem características e comportamentos comuns.

Como vimos, o mecanismo de classificação é um dos métodos que facilita a compreensão do sistema
como um todo. Cada objeto é classificado em uma determinada classe, de acordo com suas características
e comportamentos.

Chamamos o objeto de instância de uma determinada classe, o que significa que ele possui o
comportamento e as características definidos pela classe para suas instâncias. A instanciação é o processo
contrário ao de classificação, e consiste em criar um novo objeto a partir de uma classe.

A ênfase da metodologia de orientação a objetos será dada na definição de classes, e não de objetos, como
se poderia pensar pelo nome.

No nosso exemplo de Gerenciamento de Biblioteca , após encontrarmos os objetos, criaríamos as classes.

Cada publicação da estante seria classificado como um objeto da classe Publicações, já que possuiria os
mesmos atributos e serviços. Note que o conteúdo de cada atributo irá variar para cada objeto (cada
publicação tem uma editora diferente), mas todos possuem os mesmos atributos (todas as publicações
possuem uma editora). Já um usuário não irá pertencer a classe Publicações, pois, apesar de oferecer os
mesmos serviços, não possui os mesmos atributos (não possui editora, por exemplo).

Todo objeto pertence a apenas uma classe ao longo de sua existência, não podendo modificar sua
classificação.

Variávies de Instância

Os atributos de uma classe também podem ser objetos. Neste caso, estes atributos são chamados de
variáveis de instancia.
102
 Pascal para Delphi ®

Por exemplo, a classe Publicações contém os atributos identificador, editora, título, presença e tipo. Se
for do interesse do analista, poderíamos transformar o atributo editora em uma classe: a classe Editora,
com atributos nome e endereço. Ou seja, a classe Publicações teria como atributos identificador, título,
presença, tipo e um objeto da classe editora:

Encapsulamento

Como vimos no capítulo anterior, encapsulamos detalhes de sistemas complexos para melhor
compreendê-los. Na metodologia de orientação a objetos, encapsulamos atributos e serviços dentro das
classes.

O analista oferece ao programador, por exemplo, a classe Publicações, mostrando quais os atributos dos
objetos desta classe, e quais os serviços oferecidos por esta. Mas o programador não tem acesso a
implementação desses atributos e serviços (ou seja, acesso as linhas de código que os controla). Estes
dados estão encapsulados, ou seja, escondidos do programador.

Relacionamento entre Classes

Como vimos, as classes são criadas após a obtenção dos objetos. Novas classes podem ser criadas, ao
analisarmos o relacionamento existente entre as classes já encontradas.

Generalização/Especialização

Especialização é quando, dada uma determinada classe ou categoria, criamos uma outra, com novos
atributos ou serviços que a tornam mais restrita.

Generalização é a operação inversa, ou seja, é a remoção de uma ou mais características de determinada

classe, de modo a formar uma classe mais abrangente.

Por exemplo, podemos criar a classe Livros e a classe Revistas, ao especilizarmos a classe Publicações. A
classe Livros, por exemplo, teria todos os atributos da classe Publicações mais o atributo autor.

Já a classe Revista teria todos os atributos da classe Publicações mais o atributo período. Assim, a classe
Livros e a classe Revistas seriam especializações da classe Publicações:

103
 Pascal para Delphi ®

Em outro exemplo, Estudante de Graduação e Estudante de Pós Graduação podem ser considerados
especializações da classe Estudante. Esta categoria é considerada uma generalização das duas primeiras.

Herança é o mecanismo pelo qual uma classe obtém as características de outra classe para expandi-la ou
especializa-la de alguma forma, em um relacionamento de generalização/especialização.

Quando definimos uma classe podemos defini-la como sendo uma sub-classe de outra
já definida, constituindo assim uma relação de herança entre elas. A classe da qual estamos herdando
características será então chamada de superclasse (ou classe base) da nova classe. Em nosso exemplo, a
classe Publicações seria a superclasse (ou classe base) das classes Livros e Revistas.

Através do mecanismo de herança simples criamos um nova classe baseada apenas em uma única super-
classe. Já na herança multipla, criamos uma nova classe baseada em duas ou mais super-classes,
acrescentando novos atributos ou serviços.

Agregação/Decomposição (Todo / Parte)

Agregar significa juntar, colar, grudar. Neste contexto, dizemos que agregação é o ato de agregar duas ou
mais classes para formar uma nova classe.

Decomposição equivale a divisão. Decompor uma classe significa dividi-la em várias classes menores e
mais simples (refinamentos sucessivos). É o processo oposto à agregação.

Como vimos em nosso exemplo, a classe Publicações possui o atributo Editora. Como fizemos,
poderíamos transformar o atributo Editora em uma nova classe. A classe Editora conteria os atributos
nome e endereço. A classe Editora "faria parte", ou seja, estaria agregada à classe Livro, caracterizando
um relacionamento Todo/Parte entre as classes Publicações e Editora.

104
 Pascal para Delphi ®

Em outro exemplo, podemos dizer que as categorias Nome e Endereço agregadas formam a categoria
Estudante. Já a decomposição da categoria Estudante resulta nas categorias Nome e Endereço.

Mensagens

Como vimos no capítulo anterior, um sistema complexo só funciona através da cooperação entre suas
partes. Esta cooperação é feita através do envio de mensagens. Transportando esta imagem para o modelo
de orientação a objetos, podemos dizer que um objeto se comunica com outro através do envio de
mensagens.

Para entender melhor o conceito de mensagens, vamos supor que um usuário de nossa biblioteca queira
pegar um livro emprestado.

O primeiro procedimento da bibliotecária será verificar se o usuário já está cadastrado na biblioteca. Para
essa verificação, o objeto Movimentação enviará uma mensagem para o objeto Usuário: Verificar
Usuário.

Ao receber esta mensagem, o objeto Usuário dará início ao serviço VerificaUsuário(), devolvendo uma
resposta (ou seja, tendo um determinado comportamento): o usuário está cadastrado ou não.

Acoplamento Dinâmico

Como vimos, ao receber uma mensagem o objeto terá um determinado tipo de comportamento, de acordo
com o serviço chamado pela mensagem.

Ao receber uma mensagem, o objeto verificará se há na classe a qual ele pertence um serviço que defina
seu comportamento perante esta mensagem. Caso ele não encontre, verificará nas super-classes da classe
(ou seja, nas classes que a originaram) se alguma delas possui um serviço que responda aquela
mensagem. Este mecanismo de busca de serviços é chamado de acoplamento dinâmico.

105
 Pascal para Delphi ®

O mecanismo de acoplamento dinâmico é importantíssimo para a flexibilidade do modelo de objetos,

porque evita que você tenha que definir o mesmo serviço em todas as classes. Basta definí-lo na classe de
origem.

106
 Pascal para Delphi ®

Orientação a Objetos em Pascal

Para criarmos um objeto em Pascal utilizamos a palavra reservada object. O Delphi, no entanto, no lugar
de object, utiliza a palavra reservada class, porque na realidade criamos uma classe em Delphi, e não
apenas um objeto.

Apesar de similar ao tipo de dado record (registro), uma classe pode ter, além de dados, procedures, e
funções.

Os dados correspondem aos atributos ou propriedades da classe; já as procedures ou funções

correspondem aos métodos ou serviços da classe, conforme definição vista no capítulo anterior.

Criamos a classe na cláusula type da seção interface da unit:

type
nome_classe = class
dado1 : tipo_do_dado;
dado2 : tipo_do_dado;
.....
declaração da função construtora;
declaração das procedures e funções da classe;
end;

A função construtora e as demais funções devem ser implementadas na seção implementation da unit:

implementation

função construtora;
begin
....
end;

implementação das outras funções;

begin
...
end;

end.

A função construtora é usada para inicializar todas as variáveis dentro da classe e fazer qualquer outra
operação que precisa ser feita pelo objeto desta classe.

O Pascal utiliza o método Init, para a função construtora. Já o Delphi utiliza o método Create:

constructor Create(....);

107
 Pascal para Delphi ®

Note que na implementação dos métodos da classe devemos usar a seguinte sintaxe:

procedure classe.nome_procedure (parâmetros);

Para usarmos a classe criada, precisamos criar uma variável do tipo da classe criada, ou seja, precisamos
criar um objeto daquela classe. Isso é feito na seção var da unit:

var
nome_variável : nome_classe;

As variáveis do tipo da classe são também chamadas de instâncias da classe.

Vamos criar uma variável para manipularmos os atributos e métodos da classe TRetangulo, definida
anteriormente:

var
Ret1 : TRetangulo;

Após criarmos uma variável do tipo da classe, precisamos separar um espaço na memória para ela. Isto é
feito através da chamada a função construtora da classe:

variavel_da_classe := [Link];

Por exemplo:

Ret1 := [Link];

Podemos, então, manipular seus atributos e métodos. Isto é feito utilizando-se a seguinte sintaxe:

[Link];

ou

[Link];

Como vimos anteriormente, as units são conjuntos de procedimentos e funções que podem ser usadas por
diversos programas, aumentando a produtividade do desenvolvimento.

Uma classe pode (e deve) ser criada em sua própria unit, de forma que você não precise reconstruí-la toda
vez que for usá-la. Basta acrescentar o nome de sua unit à cláusula uses da unit que a vai usar.

Exemplo 24

Vamos criar uma classe TRetangulo, que conterá dois atributos, altura e largura, e dois métodos, um para
atribuir valores para os atributos, e outro que calcula a área do objeto Retangulo:

unit Unit1;
interface
type
TRetangulo = class
altura : integer;

108
 Pascal para Delphi ®

largura : integer;
constructor Create(alt, larg : integer);
procedure AtribuiDados(alt, larg : integer);
function CalculaArea : integer;
end;
implementation
constructor [Link](alt, larg : integer);
begin
altura := alt;
largura := larg;
end;
procedure [Link]( alt, larg:integer);
begin
altura := alt;
largura := larg;
end;
function [Link] : integer;
begin
CalculaArea := altura * largura;
end;
end.

Criamos, portanto, uma classe TRetangulo que possui dois atributos: largura e altura, uma função
construtora, que inicializa estes atributos, e dois métodos. O primeiro método AtribuiDados, atribui aos
atributos determinado valor. O segundo método, CalculaArea, calcula a área do retangulo, ao multiplicar
os valores de altura e largura.

Vamos agora utilizar a classe TRetangulo criada:

unit Unit1;
interface
type
TRetangulo = class
altura : integer;
largura : integer;
constructor Create(alt, larg: integer);
procedure AtribuiDados(alt, larg : integer);
function CalculaArea : integer;
end;
var
Pequeno,Medio,Grande: TRetangulo;
implementation
constructor [Link](alt , larg : integer);
begin
altura := alt;
largura := larg;
end;
procedure [Link]( alt, larg : integer);
begin
altura := alt;
largura := larg;
end;
109
 Pascal para Delphi ®

function [Link] : integer;

begin
CalculaArea := altura * largura;
end;
procedure [Link] (Sender: TObject);
begin
Pequeno:=[Link](8,8);
Medio:=[Link](10,12);
Grande := [Link](15,20);
ShowMessage('A área do retangulo pequeno é ' +
InttoStr( [Link]));
ShowMessage('A área do retangulo médio é ' +
InttoStr( [Link]));
ShowMessage('A área do retangulo grande é ' +
InttoStr( [Link]));
end;
end.

Ou seja, criamos a classe TRetangulo e, para manipulá-la, criamos três objetos: Pequeno, Medio e
Grande, todos do tipo TRetangulo.

Chamamos então o método Create da classe TRetangulo, que inicializa seus atributos com os parâmetros
passados. Por exemplo, para a instancia Pequeno, inicializamos o retângulo com os valores 8 de altura e 8
de largura. Fazemos o mesmo para as instancias Medio e Grande da classe TRetangulo.

Depois, calculamos a área do retangulo, através da chamada ao método CalculaArea da classe

TRetangulo, que multiplica os valores da largura e altura atribuidas no método de inicialização. Por
exemplo, para o retangulo pequeno, cuja altura e largura foram inicializadas com o valor de 8, temos uma
área de 64. Este valor é mostrado então na tela, através do comando ShowMessage. Repetimos o
procedimento anterior para as demais instancias da classe TRetangulo.

Como novo exemplo, vamos criar uma unit que utilize a classe de nome TVeiculo, armazenado em uma
unit denominada Unidade3. Inicialmente, vamos criar a unit, e nela construir o objeto TVeiculo. Este
objeto possui dois atributos, Peso e Pneus, um método construtor, e um método que calcula o peso
carregado por cada pneu:

unit Unidade3;
interface
type
TVeiculo = class
Pneus : integer;
Peso : real;
constructor Create(n_pneus: integer; n_peso: real);
function AtribuiPneus : integer;
function AtribuiPeso : real;
function CarregamentoPneus : real;
end;
implementation
constructor [Link]( n_pneus : integer; n_peso : real);
begin
Pneus := n_pneus;
Peso := n_peso;
110
 Pascal para Delphi ®

end;
function [Link] : integer;
begin
AtribuiPneus := Pneus;
end;
function [Link] : real;
begin
AtribuiPeso := Peso;
end;
function [Link] : real;
begin
CarregamentoPneus := Peso/ Pneus;
end;
end.

Não esqueça de salvar esta unit criada, através do comando File | Save, dando a ela o nome [Link].
Se você não salvá-la, não poderá acrescentá-la à cláusula uses da unit que a usará.

Agora, vamos criar a unit que usa a classe TVeiculo criada na unit Unidade3. Note que incluímos a unit
Unidade3 na cláusula uses:

unit Unit1;
interface
uses
Unidade3;
var
Veic1 : TVeiculo;
implementation
{$R *.DFM}
procedure [Link]( Sender: TObject);
begin
Veic1 := [Link](1,50);
ShowMessage('O veiculo pesa ' + FloattoStr([Link]) +
' quilos, e possui ' + FloattoStr([Link]) + 'pneus.');
end;
end.

111