ARQUIVO 2
Autor: Ayrton Pipo | Publicado: 2010-05-10T23:44:00-07:00

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 ﬂ‡ BUFFER ﬂ‡ 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’);
&nbsp;
&nbsp;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 &lt;&gt; 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.