ARQUIVO 2

Declaração e Assinalamento de Arquivos-Texto

O Pascal usa a palavra reservada TEXT como identificador padrão de arquivos-texto. A sintaxe para definir
variáveis desse tipo:

var
arq_alunos: text;
arq_func: text[512];


Os arquivos-texto são definidos inicialmente com memória temporária de 128 bytes. Isto quer dizer que o
Pascal trabalha com 128 bytes de informações de cada vez. Esse tamanho de memória temporária é
adequado para a maioria das aplicações. Entretanto, no caso de programas que utilizam repetidamente
informações guardadas em disquetes, como é o caso de programas de banco de dados, pode ser
conveniente aumentar a capacidade de memória temporária. Para estabelecer o tamanho da memória
temporária, basta colocar o número de bytes desejado entre colchetes depois da palavra TEXT, na
declaração da variável de arquivo (como no exemplo acima).

Normalmente, declaramos uma variável de memória, do mesmo tipo de dados que vão ser gravados ou
lidos no arquivo. É essa variável que guarda em memória os conteúdos dos registros que vão ser lidos do
arquivo ou que vão ser gravados no arquivo. Todo o manuseio com os dados é feito em memória. O arquivo
de dados é utilizado apenas para gravar ou ler informações.

Exemplo:
type dados = record
nome: string[30];
tel: string[10];
end;
var
arq_alunos: text;
registro: dados;


Para utilizarmos uma variável de arquivo para acessar um arquivo-texto, temos que associar a variável a um
determinado nome de arquivo em disco. Denominamos esse processo de assinalamento. A procedure
predefinida que executa esta tarefa é ASSIGN. Assign associa o nome da variável de arquivo a um nome de
arquivo em disco. Nunca deve ser usada em arquivos que já estejam em uso.

Exemplo:
assign (arq_alunos,’ALUNOS.DAT’);

A partir desse comando, toda referência a “arq_alunos” no programa será dirigida ao arquivo no disco
chamado “alunos.dat”.

Caso um programa tenha mais de uma variável de arquivo, teremos que assinalar indiv idualmente cada
variável, isto é, teremos tantos assign quanto forem as variáveis de arquivo.

Assinalar uma variável arquivo é criar um buffer específico para aquela variável. Um buffer é uma parte da
memória do computador, com determinada capacidade, que é criada para atuar como intermediário entre o
programa e o arquivo de dados no disco. A informação que se encontra no disco, primeiro é copiada para
buffer, uma determinada quantidade de bytes de cada vez, estando, portanto, disponível ao programa para
manipulação. Do mesmo modo, as informações, para serem gravadas em disco, são primeiramente
acumuladas no buffer. Quando o buffer está cheio, as informações são copiadas para o disco.

ALUNOS.DAT fl‡ BUFFER fl‡ MEMÓRIA

Graças aos buffers, os dados são movimentados corretamente, para os arquivos especificados.

O default de arquivos que podem ser abertos simultaneamente no Pascal é 16. Se você deseja aumentar o
número de arquivos que podem permanecer abertos basta usar a diretiva F do compilador. {$F20}.

Você também pode alterar o número de arquivos abertos ao dar “boot” no sistema, uando a declaração
FILES do arquivo CONFIG.SYS, além também de poder estabelecer o número de buffers utilizáveis
(BUFFERS).

Exemplo:
{$F20}
uses crt;
type dados = record
nome: string[30];
tel: string[10];
end;
var
arq_alunos: text;
registro: dados;
begin
clrscr;
assign(arq_alunos,’ALUNSO.DAT’);
 

 Abrindo um Arquivo-Texto

Um determinado arquivo-texto pode ser aberto para leitura ou gravação, mas não para ambas operações ao
mesmo tempo.

O Turbo Pascal fornece três procedures diferentes para abertura de um arquivo-texto:

a) Rewrite (var de arquivo): cria um novo arquivo e o abre para operações de escrita. Após a abertura,
podemos usar procedures WRITE e WRITELN para escrever os dados e linhas de texto no arquivo.
Caso o nome do arquivo já exista no disco, este procedimento destrói o arquivo antigo e cria outro
vazio e com o mesmo nome, isto significa que todos os dados do arquivo existente serão perdidos.

b) APPEND (var de arquivo): abre um arquivo-texto já existente, de modo que podemos adicionar
novos registros no fim do arquivo. Ocorre um erro de I/O se o arquivo não existir no disco. Após a
abertura, podemos usar as procedures WRITE e WRITELN para escrever dados no arquivo.

c) RESET(var de arquivo): abre um arquivo já existente para leitura. Após a abertura do arquivo,
podemos usar as procedures READ e READLN para lermos dados e linhas de texto do arquivo.

Em contraste com a procedure REWRITE que cria um arquivo novo destruindo o antigo, caso exista, as
procedures APPEND e RESET assumem a existência de um arquivo nomeado no disco. Se o arquivo não
puder ser localizado, em ambos os casos, resultarão em erros de I/O em tempo de execução.

Exemplo:
uses crt;
type dados = record
nome: string;
tel: string;
end;
var
registro: dados;
arq_reg: text;
begin
clrscr;
assign(arq_reg,’ALUNOS.DAT’);
{$I-}
reset(arq_reg);
{$I+}
if IOResult = 0 then
write(‘Arquivo “ALUNOS.DAT” aberto para leitura’);
else
begin
rewrite(arq_reg);
write(‘Arquivo ALUNOS.DAT criado’);
end;
readkey;
close(arq_reg);
end.


Escrevendo Dados num Arquivo-Texto:

Veja o programa-exemplo abaixo:

uses crt;
type dados = record
nome: string;
tel: string;
end;
var
registro: dados;
arq_reg: text;
conf: char;
begin
clrscr;
assign(arq_reg,’ALUNOS.DAT’);
{$I-}
append(arq_reg);
{$I+}
if IOResult = 0 then
writeln(‘Arquivo “ALUNOS.DAT” aberto para leitura’);
else
begin
rewrite(arq_reg); write(‘Arquivo ALUNOS.DAT criado’);
end;
readkey;
repeat
write(‘Entre com um nome: ‘); readln(registro.nome);
write(‘Seu telefone: ‘); readln(registro.tel);
write(‘Confirma gravação ? : ‘); conf := upcase(readkey);
if conf = ‘S’ then
writeln(arq_reg,registro.nome,#32,registro.tel);
until conf=’N’;
close(arq_reg);
end.


Observe que o comando WRITELN automaticamente insere ao final da linha um caracter de retorno de
carro (#13) e um de alimentação de linha (#10).

Podem ser usados como caracteres delimitadores de campos: espaço (#32) e tabulação (#9).



Fechando um Arquivo-Texto:

Para fechar qualquer arquivo aberto, o Pascal dispõe da procedure CLOSE, como foi visto nos exemplos
anteriores de programas.

Notas sobre o comando close:

· Se vários arquivos foram abertos simultaneamente, teremos que fechá-los individualmente, usando um
comando close para cada um.

· O comando CLOSE fecha o arquivo externo em disco, mas não termina com o assinalamento feito pelo
comando ASSIGN. Isto significa que o programa pode usar um comando REWRITE, RESET ou
APPEND após o comando CLOSE se necessário.

· CLOSE é um comando muito importante, pois é usado para manter a integridade e exatidão dos
arquivos de dados. Relembre que o buffer atua como um intermediário entre o programa e o arquivo em
disco. Quando se executa uma operação de gravação, os dados são enviados primeiramente para o
buffer. Quando o buffer está cheio, os dados são gravados em disco. Freqüentemente essa operação é
chamada de atualização de arquivos em disco.

O que acontece quando o buffer só está parcialmente cheio e não existem mais dados para preenchê-lo. Se
você está esperando que o buffer semi-cheio simplesmente transfira seu conteúdo para o disco quando o
programa termina a sua e xecução, você está enganado. Os dados de um buffer semi-cheio não são
necessariamente gravados no arquivo.

O comando CLOSE força o buffer a transferir o seu conteúdo para o arquivo de disco, mesmo que o buffer
não esteja cheio.

Apostila de Turbo Pascal 7.0


8. Lendo Dados de um Arquivo-Texto

Veja o programa-exemplo abaixo:
uses crt;
type dados = record
nome: string;
tel: string;
end;
var
registro: dados;
arq_reg: text;
conf: char;
begin
clrscr;
assign(arq_reg,’ALUNOS.DAT’);
{$I-}
reset(arq_reg);
{$I+} {tentando abrir para leitura}
if IOResult <> 0 then
exit; {algum problema, fim}
with registro do
begin
repeat
readln(arq_reg,nome,tel); {lendo do arquivo}
write(nome,‘ ’,tel); {listando na tela}
until eof(arq_reg); {repita até que o final do arquivo seja atingido}
end;
close(arq_reg);
readkey;
end.

· Quando o programa está lendo uma seqüência de valores de um arquivo texto, a procedure READ
reconhece os caracteres delimitadores usados durante o processo de gravação.

· O arquivo-texto foi projetado para conter só caracteres ASCII. Mesmo assim, as procedures READ e
READLN podem ler apropriadamente valores de dados numéricos ou strings. É evidente que durante
um processo de leitura, não podemos colocar valor de uma variável string numa variável numérica.

· Já foi dito que um arquivo-texto é um arquivo seqüencial, por isso é necessário sabermos quando o fim
de arquivo foi atingido. A quantidade de linhas gravadas pode ser controlada pelo programador, através
de técnicas, porém, o modo mais prático para se descobrir o fim do arquivo é usado a função booleana
EOF, como foi aplicado no exemplo acima.

A função EOF retorna true se o ponteiro estiver no final do arquivo. Caso contrário, a função retornará false,
indicando que o fim do arquivo não foi atingido.