Tutorial pascal arquivos

1. ARQUIVOS
DISCIPLINA DE ALGORITMOS E
ESTRUTURAS DE DADOS
Prof.ª M.ª Eng.ª Elaine Cecília Gatto
Bauru-SP
2015

2. Sumário
1. ARQUIVOS...............................................................................................................................................3
1.1. Declaração de Arquivos......................................................................................................................3
1.1.1. Sintaxe .........................................................................................................................................3
1.1.2. Exemplo.......................................................................................................................................3
1.2. Associação de variáveis a arquivos ....................................................................................................3
1.3. Criação de novos arquivos..................................................................................................................4
1.4. Abrindo arquivos existentes ...............................................................................................................4
1.5. Fechando arquivos ..............................................................................................................................4
1.6. Lendo arquivos ...................................................................................................................................5
1.7. Gravando dados em um arquivos .......................................................................................................5
1.8. Movimentação do Ponteiro.................................................................................................................5
1.9. Tamanho do Arquivo..........................................................................................................................5
2.0. Posição do ponteiro.............................................................................................................................5
2.1. Verificação do fim de arquivo ............................................................................................................6
2.2. Exemplos ............................................................................................................................................6
Exemplo 1..............................................................................................................................................6
Exemplo 2: Incluindo clientes no arquivo criado ..................................................................................7
Passo 3: Inclua contas para os clientes cadastrados no arquivo criado .................................................9
Exemplo 4: Consultando o saldo de todas as contas de um cliente cadastrado...................................12
Exemplo 5: Atualizando o saldo de um cliente a partir de um depósito .............................................13
Exemplo 6: Atualizando o saldo de um cliente a partir de um saque ..................................................14
2.3. Exercícios .........................................................................................................................................16

3. 1. ARQUIVOS
1.1. Declaração de Arquivos
1.1.1. Sintaxe
TYPE nome_do_registro = RECORD
nome_do_campo_1: tipo_do_dado;
nome_do_campo_2: tipo_do_dado;
nome_do_campo_3: tipo_do_dado;
...
END;
nome_do_arquivo = FILE OF nome_do_registro;
VAR
variável_do_arquivo : nome_do_arquivo;
variável_do_registro: nome_do_registro;
1.1.2. Exemplo
Exemplo 1:
TYPE registro = RECORD
nome : string[30];
endereco : string[20];
telephone : string[10];
END;
arquivo = FILE OF registro;
VAR
agenda : arquivo;
reg : registro;
Exemplo 2:
TYPE carro = RECORD
placa : string[7];
marca : string[20];
ano : integer
END;
Frota = FILE OF carro;
VAR
Detran : frota;
Carros : carro;
1.2. Associação de variáveis a arquivos
ASSIGN: comando usado para associar nomes de arquivos FÍSICOS à variáveis de programa.
Assim uma ligação é estabelecida entre a memória principal (RAM) e a memória secundária (HD).
Sintaxe:
ASSIGN (nome_da_variavel_do_tipo_arquivo, ‘caminho do arquivo no disco’);

4. Exemplo 1:
ASSIGN(agenda, ‘agenda.dat’);
Exemplo 2:
ASSIGN(detran, ‘c:exemploscarros.dat’);
1.3. Criação de novos arquivos
REWRITE: comando utilizado para criar um novo arquivo. Posiciona o ponteiro no primeiro
registro do arquivo quando utilizado. Existem duas condições:
a) arquivo já existente: se o camando REWRITE for utilizado para fazer referencia a um arquivo que
já exista em seu HD, todos os dados que estão armazenados nesse arquivo serão DESTRUÍDOS.
b) Arquivo não existente: força a criação do arquivo.
Sintaxe:
REWRITE(nome_da_variável_do_tipo_arquivo);
Exemplo 1:
REWRITE(detran);
Exemplo 2:
REWRITE(agenda);
1.4. Abrindo arquivos existentes
RESET: comando utilizado para abrir arquivos já criados. O ponteiro deve ser posicionado no
primeiro registro, sem destruir os dados já existentes no arquivo.
Sintaxe:
RESET(nome_da_variável_do_tipo_arquivo);
Exemplo 1:
RESET(detran);
Exemplo 2:
RESET(agenda);
1.5. Fechando arquivos
CLOSE: comando utilizado para fechar arquivos abertos pelo comando REWRITE ou RESET.
Todas as alterações feitas em um arquivo só serão efetivamente realizadas quando o mesmo for fechado.
Sintaxe:
CLOSE(nome_da_variável_do_tipo_arquivo);
Exemplo 1:
CLOSE(detran);
Exemplo 2:
CLOSE(agenda);

5. 1.6. Lendo arquivos
READ: comando utilizado para ler arquivos. Uma leitura em disco deve ser executada para ler os
dados contidos em um arquivo.
Sintaxe:
READ(nome_da_variável_do_tipo_arquivo, nome_da_variavel_do_tipo_registro);
Exemplo 1:
READ(detran, carros);
Exemplo 2:
READ(agenda, reg);
1.7. Gravando dados em um arquivos
WRITE: comando utilizado para gravar dados em arquivos.
Sintaxe:
WRITE(nome_da_variável_do_tipo_arquivo, nome_da_variavel_do_tipo_registro);
Exemplo 1:
WRITE(detran, carros);
Exemplo 2:
WRITE(agenda, reg);
1.8. Movimentação do Ponteiro
SEEK: posiciona o ponteiro no registro desejado. O primeiro registro do arquivo é sempre o
número zero.
Sintaxe:
SEEK(nome_da_variável_do_tipo_arquivo, numero_do_registro);
Exemplo 1:
SEEK(detran, 0);
Exemplo 2:
SEEK(agenda, 0);
1.9. Tamanho do Arquivo
FILEZISE: retorna o número de registros existentes em um arquivo.
Sintaxe:
FILEZISE(nome_da_variável_do_tipo_arquivo);
Exemplo 1:
int tamanho := FILEZISE(agenda);
Exemplo 2:
int tamanho := FILEZISE(detran);
2.0. Posição do ponteiro
FILEPOS: retorna o número do registro onde o ponteiro está localizado.

6. Sintaxe:
int posicao := FILEPOS(nome_da_variavel_do_tipo_arquivo);
Exemplo 1:
int posicao := FILEPOS(agenda);
Exemplo 2:
int posicao := FILEPOS(detran);
2.1. Verificação do fim de arquivo
NOT EOF: verifica se o ponteiro chegou ao final do arquivo. Retorno desta função:
a) Verdadeiro: se o final do arquivo foi encontrado
b) Falso: se o final do arquivo não foi encontrado
Sintaxe:
WHILE NOT EOF (nome_da_variavel_do_tipo_arquivo) DO
BEGIN
Comandos;
END;
Exemplo 1:
WHILE NOT EOF (detran) DO
BEGIN
READ(detran, carros);
END;
Exemplo 2:
WHILE NOT EOF (agenda) DO
BEGIN
READ(agenda, reg);
END;
2.2. Exemplos
Exemplo 1
Criando dois arquivos, um para armazenar dados de clientes e, outro, para armazenar dados da
conta bancária desses clientes, conforme ilustram as tabelas abaixo.
Clientes Conta Bancaria
Numero do cliente Número da conta
Nome do cliente Número do cliente
Saldo
PROGRAM EXEMPLO;
USES CRT;
TYPE cliente = RECORD
numero : INTEGER;
nome : STRING[20];
ativo: INTEGER;
END;

7. clientes = FILE OF cliente;
TYPE conta = RECORD
numero_conta : INTEGER;
numero_cli : INTEGER;
saldo : REAL;
ativo: INTEGER;
END;
contas = FILE OF conta;
VAR
cli: clientes;
cl: cliente;
com: contas;
co: conta;
BEGIN
CLRSCR;
ASSIGN(CLI, 'C:CLIENTES.DAT');
REWRITE(CLI);
CLOSE(CLI);
WRITELN('ARQUIVO DE CLIENTES CRIADO COM SUCESSO ');
ASSIGN(COM, 'C:CONTAS.DAT');
REWRITE(COM);
CLOSE(COM);
WRITELN('ARQUIVO DE CONTAS CRIADO COM SUCESSO ');
READLN;
END.
Exemplo 2: Incluindo clientes no arquivo criado
PROGRAM EXEMPLO;
USES CRT;
TYPE cliente = RECORD
numero, ativo : INTEGER;
nome : STRING[20];
END;
clientes = FILE OF cliente;
VAR
cli: clientes;
cl: cliente;
K, I, P, POSICAO: INTEGER;
ACHOU : BOOLEAN;
NUMERO: INTEGER;
NOME: STRING[20];
BEGIN

8. CLRSCR;
ASSIGN(CLI, 'C:CLIENTES.DAT');
{$I-}
RESET(CLI);
{$I+}
IF IORESULT = 2
THEN REWRITE(CLI);
K := FILESIZE(CLI);
WRITE('DIGITE O NéMERO DO CLIENTE A SER INCLUÖDO ');
READLN(NUMERO);
IF K = 0
THEN BEGIN
WRITE('DIGITE O NOME DO CLIENTE A SER INCLUÖDO ');
READLN(NOME);
CL.NUMERO := NUMERO;
CL.NOME := NOME;
CL.ATIVO := 1;
WRITE(CLI, CL);
WRITELN('CLIENTE INCLUÖDO');
END
ELSE BEGIN
I := 0;
ACHOU := FALSE;
POSICAO := 0;
RESET(CLI);
WHILE ( I <= (K-1)) DO
BEGIN
READ(CLI, CL);
IF (CL.NUMERO = NUMERO) AND (CL.ATIVO = 1)
THEN BEGIN
ACHOU := TRUE;
I := K + 2;
END
ELSE BEGIN
IF NUMERO < CL.NUMERO
THEN BEGIN
POSICAO := FILEPOS(CLI) - 1;
I := K + 2;
END
ELSE BEGIN
I := I+1;
SEEK(CLI, I);
END;
END;
END;
IF ACHOU = TRUE
THEN WRITELN('JA EXISTE CLIENTE CADASTRADO COM ESTE CODIGO ')
ELSE BEGIN

9. IF I = FILESIZE(CLI)
THEN BEGIN
WRITE('DIGITE O NOME DO CLIENTE A SER INCLUÖDO ');
READLN(NOME);
SEEK(CLI, FILESIZE(CLI));
CL.NUMERO := NUMERO;
CL.NOME := NOME;
CL.ATIVO := 1;
WRITE(CLI, CL);
WRITELN('CLIENTE INCLUÖDO');
END
ELSE BEGIN
P := FILESIZE(CLI) - 1;
WHILE P >= POSICAO DO
BEGIN
SEEK(CLI,P);
READ(CLI,CL);
WRITE(CLI,CL);
P := P - 1 ;
END;
SEEK(CLI, POSICAO);
WRITE('DIGITE O NOME DO CLIENTE A SER INCLUÖDO ');
READLN(NOME);
CL.NUMERO := NUMERO;
CL.NOME := NOME;
CL.ATIVO := 1;
WRITE(CLI, CL);
WRITELN('CLIENTE INCLUÖDO');
END;
END;
END;
READLN;
CLOSE(CLI);
END.
Passo 3: Inclua contas para os clientes cadastrados no arquivo criado
PROGRAM EXEMPLO;
USES CRT;
TYPE cliente = RECORD
numero : INTEGER;
nome : STRING[20];
ativo: INTEGER;
END;
clientes = FILE OF cliente;
TYPE conta = RECORD
numero_conta : INTEGER;

10. numero_cli : INTEGER;
saldo : REAL;
ativo: INTEGER;
END;
contas = FILE OF conta;
VAR
con: contas;
co: conta;
cli: clientes;
cl: cliente;
K, I, P, POSICAO : INTEGER;
ACHOU : BOOLEAN;
NUM_CONTA, NUM_CLIENTE: INTEGER;
SALDO: REAL;
BEGIN
CLRSCR;
ASSIGN(CON, 'C:CONTAS.DAT');
{$I-}
RESET(CON);
{$I+}
IF IORESULT = 2 THEN
REWRITE(CON);
ASSIGN(CLI, 'C:CLIENTES.DAT');
{$I-}
RESET(CLI);
{$I+}
IF IORESULT = 2 THEN
REWRITE(CLI);
K := FILESIZE(CON);
WRITE('DIGITE O NéMERO DA CONTA A SER INCLUÖDA ');
READLN(NUM_CONTA);
WRITE('DIGITE O NéMERO DO CLIENTE DA CONTA ');
READLN(NUM_CLIENTE);
WRITE('DIGITE O SALDO ');
READLN(SALDO);
ACHOU:=FALSE;
WHILE NOT EOF(CLI) DO
BEGIN
READ(CLI,CL);
IF (CL.NUMERO = NUM_CLIENTE) AND (CL.ATIVO = 1)
THEN ACHOU:=TRUE;
END;
IF ACHOU = FALSE
THEN WRITELN('ESTE CLIENTE NÇO ESTµ CADASTRADO')
ELSE BEGIN

11. ACHOU:=FALSE;
IF K = 0
THEN BEGIN
CO.NUMERO_CONTA := NUM_CONTA;
CO.NUMERO_CLI := NUM_CLIENTE;
CO.SALDO:= SALDO;
CO.ATIVO:=1;
WRITE(CON,CO);
WRITELN('CONTA INCLUÖDA');
END
ELSE BEGIN
I := 0;
ACHOU := FALSE;
POSICAO := 0;
RESET(CON);
WHILE ( I <= (K-1)) DO
BEGIN
READ(CON, CO);
IF (CO.NUMERO_CONTA = NUM_CONTA) AND (CO.ATIVO = 1)
THEN BEGIN
ACHOU := TRUE;
I := K + 2;
END
ELSE BEGIN
IF NUM_CONTA < CO.NUMERO_CONTA
THEN BEGIN
POSICAO := FILEPOS(CON) - 1;
I := K + 2;
END
ELSE BEGIN
I := I+1;
SEEK(CON, I);
END;
END;
END;
IF ACHOU = TRUE
THEN WRITELN('JA EXISTE CONTA CADASTRADA COM ESTE NUMERO ')
ELSE BEGIN
IF I = FILESIZE(CON)
THEN BEGIN
SEEK(CON, FILESIZE(CON));
CO.NUMERO_CONTA := NUM_CONTA;
CO.NUMERO_CLI := NUM_CLIENTE;
CO.SALDO:= SALDO;
CO.ATIVO:=1;
WRITE(CON, CO);
WRITELN('CONTA INCLUÖDA');
END
ELSE BEGIN

12. P := FILESIZE(CON) - 1;
WHILE P >= POSICAO DO
BEGIN
SEEK(CON,P);
READ(CON,CO);
WRITE(CON,CO);
P := P - 1 ;
END;
SEEK(CON, POSICAO);
CO.NUMERO_CONTA := NUM_CONTA;
CO.NUMERO_CLI := NUM_CLIENTE;
CO.SALDO:= SALDO;
CO.ATIVO:=1;
WRITE(CON, CO);
WRITELN('CONTA INCLUÖDA');
END;
END;
END;
END;
READLN;
CLOSE(CLI);
CLOSE(CON);
END.
Exemplo 4: Consultando o saldo de todas as contas de um cliente cadastrado
PROGRAM EXEMPLO;
USES CRT;
TYPE cliente = RECORD
numero : INTEGER;
nome : STRING[20];
ativo: INTEGER;
END;
clientes = FILE OF cliente;
TYPE conta = RECORD
numero_conta : INTEGER;
numero_cli : INTEGER;
saldo : REAL;
ativo: integer;
END;
contas = FILE OF conta;
VAR
com: contas;
co: conta;
cli: clientes;
cl: cliente;

13. K, I : INTEGER;
ACHOU : BOOLEAN;
NUM_CLIENTE: INTEGER;
BEGIN
CLRSCR;
ASSIGN(COM, 'C:CONTAS.DAT');
RESET(COM);
ASSIGN(CLI,'C:CLIENTES.DAT');
RESET(CLI);
K := FILESIZE(COM);
WRITE('DIGITE O NéMERO DO CLIENTE DA CONTA ');
READLN(NUM_CLIENTE);
ACHOU:=FALSE;
WHILE NOT EOF(CLI) DO
BEGIN
READ(CLI,CL);
IF (CL.NUMERO = NUM_CLIENTE) AND (CL.ATIVO = 1)
THEN ACHOU:=TRUE;
END;
IF ACHOU = FALSE
THEN WRITELN('ESTE CLIENTE NÇO ESTµ CADASTRADO')
ELSE BEGIN
ACHOU:=FALSE;
WHILE NOT EOF(COM) DO
BEGIN
READ(COM,CO);
IF (CO.NUMERO_CLI = NUM_CLIENTE) AND (CO.ATIVO = 1)
THEN BEGIN
ACHOU:=TRUE;
WRITELN('CONTA ',CO.NUMERO_CONTA,' = ',CO.SALDO:5:2);
END;
END;
IF ACHOU = FALSE
THEN WRITELN('NÇO EXISTE CONTA CASTRADA PARA ESTE CLIENTE');
END;
READLN;
CLOSE(CLI);
CLOSE(COM);
END.
Exemplo 5: Atualizando o saldo de um cliente a partir de um depósito
PROGRAM EXEMPLO;
USES CRT;
TYPE conta = RECORD
numero_conta : INTEGER;
numero_cli : INTEGER;
saldo : REAL;
ativo: INTEGER;

14. END;
contas = FILE OF conta;
VAR
con: contas;
co: conta;
K, I : INTEGER;
ACHOU : BOOLEAN;
NUM_CONTA: INTEGER;
VALOR: REAL;
BEGIN
CLRSCR;
ASSIGN(CON, 'C:CONTAS.DAT');
{$I-}
RESET(CON);
{$I+}
IF IORESULT = 2
THEN REWRITE(CON);
K := FILESIZE(CON);
WRITE('DIGITE O NéMERO DA CONTA QUE SOFRERµ O DEPàSITO ');
READLN(NUM_CONTA);
ACHOU:=FALSE;
WHILE NOT EOF(CON) DO
BEGIN
READ(CON,CO);
IF (CO.NUMERO_CONTA = NUM_CONTA) AND (CO.ATIVO = 1)
THEN BEGIN
ACHOU:=TRUE;
SEEK(CON,FILEPOS(CON)-1);
WRITELN('SALDO ATUAL DA CONTA: ', CO.SALDO:7:2);
WRITE('DIGITE O VALOR DO DEPàSITO ');
READLN(VALOR);
CO.SALDO:= CO.SALDO + VALOR;
WRITE(CON,CO);
SEEK(CON,FILEPOS(CON)+1);
WRITELN('DEPàSITO EFETUADO COM SUCESSO');
END;
END;
IF ACHOU = FALSE
THEN WRITELN('ESTA CONTA NÇO ESTµ CADASTRADA');
CLOSE(CON);
READLN;
END.
Exemplo 6: Atualizando o saldo de um cliente a partir de um saque
PROGRAM EXEMPLO;
USES CRT;

15. TYPE conta = RECORD
numero_conta : INTEGER;
numero_cli : INTEGER;
saldo : REAL;
ativo: INTEGER;
END;
contas = FILE OF conta;
VAR
con: contas;
co: conta;
K, I : INTEGER;
ACHOU : BOOLEAN;
NUM_CONTA: INTEGER;
VALOR: REAL;
BEGIN
CLRSCR;
ASSIGN(CON, 'C:CONTAS.DAT');
{$I-}
RESET(CON);
{$I+}
IF IORESULT = 2 THEN
REWRITE(CON);
K := FILESIZE(CON);
WRITE('DIGITE O NéMERO DA CONTA QUE SOFRERµ O SAQUE ');
READLN(NUM_CONTA);
ACHOU:=FALSE;
WHILE NOT EOF(CON) DO
BEGIN
READ(CON,CO);
IF (CO.NUMERO_CONTA = NUM_CONTA) AND (CO.ATIVO = 1)
THEN BEGIN
ACHOU:=TRUE;
SEEK(CON,FILEPOS(CON)-1);
WRITELN('SALDO ATUAL DA CONTA: ', CO.SALDO:7:2);
WRITE('DIGITE O VALOR DO SAQUE ');
READLN(VALOR);
CO.SALDO:= CO.SALDO - VALOR;
WRITE(CON,CO);
SEEK(CON,FILEPOS(CON)+1);
WRITELN('SAQUE EFETUADO COM SUCESSO');
END;
END;
IF ACHOU = FALSE
THEN WRITELN('ESTA CONTA NÇO ESTµ CADASTRADA');
CLOSE(CON);
READLN;

16. END.
2.3. Exercícios
Faça um programa em pascal que:
1. Crie um arquivo chamado ALUNOS.DAT, no qual cada registro será composto pelos seguintes
campos: número, nome, curso, nota1, nota2, media.
2. Permita incluir 10 alunos no arquivo criado, lembrando que não podem existir dois alunos com o
mesmo número.
3. Permita alterar todas as notas dos alunos.
4. Permita alterar uma nota especifica de um aluno especifico.
5. Permita alterar o curso de todos os alunos.
6. Permita alterar o curso de um aluno especifico.
7. Permita excluir todos os alunos.
8. Permita excluir apenas um aluno especifico.
9. Permita buscar por um nome de aluno especifico.
10. Permita emitir um relatório completo da ficha de um aluno especifico.
11. Permita emitir um relatório completo de todos os alunos.
12. Permita emitir um relatório com os nomes de todos os alunos reprovados (média menor que 7)
13. Permita emitir um relatório com os nomes de todos os alunos aprovados (média maior ou igual a
7).
Para o desenvolvimento deste exercício use todos os recursos aprendidos: units, procedures,
functions, swtch/case, etc.
INSERINDO ALUNOS USANDO PROCEDURES
PROGRAM EXEMPLO;
USES CRT,WINCRT;
TYPE aluno = RECORD
numero : INTEGER;
nome : STRING[255];
nota1, nota2, media : REAL;
ativo: INTEGER;
END;
alunos = FILE OF aluno; //variável do tipo regitro cliente
VAR
alu: alunos;
al: aluno;
k, i, p, posicao, numero: INTEGER;

17. achou : BOOLEAN;
nome: STRING[255];
nota1, nota2, media: REAL;
PROCEDURE INSERIRALUNO();
begin
ASSIGN(alu, 'C:Userselaine.gattoDocumentsalunos2.txt');
{$I-}
{comando utilizado para abrir arquivos já criados
abre o arquivo ALU que já foi criado por ASSIGN }
RESET(alu);
{$I+}
if(IORESULT = 2) then
REWRITE(alu);
k := FILESIZE(alu); //k tem o tamanho do arquivo
WRITELN(' Digite o numero do aluno a ser incluido ');
READLN(numero);
{se o tamanho do arquivo for igual a zero, então o arquivo está vazio}
if(K=0)then
begin
WRITELN(' Digite o numero do aluno a ser incluido ');
READLN(numero);
WRITELN(' Digite o nome do aluno a ser incluido ');
READLN(nome);
WRITELN(' Digite a primeira nota a ser incluido ');
READLN(nota1);
WRITELN(' Digite a segunda nota a ser incluido ');
READLN(nota1);
al.numero := numero;
al.nome := nome;
al.nota1 := nota1;
al.nota2 := nota2;
al.media := (nota1+nota2)/2;
al.ativo := 1; //indica que este número de registro existe no arquivo
WRITE(alu, al);
WRITELN(' Aluno incuido com sucesso ');
end
{se o tamanho do arquivo for diferente de zero, então o arquivo não está
vazio - cuidado para não apagar o que já existe!}
else begin
i := 0;
achou := false; //seta a variavel auxiliar ACHOU como falsa

18. posicao := 0;
RESET(alu); //abre o arquivo existente
//enquanto i menor que o tamanho do arquivo - 1
while( i <= (k-1))do
begin
//faz a leitura dos dados do arquivo
READ(alu, al);
{ se o número digitado for igual ao número do registro
e se ativo for igual a 1, então registro existe}
if((al.numero = numero) AND (al.ativo = 1)) then
begin
achou := true; //encontrou o registro!!! seta como verdadeiro
i := k + 2;
end
else begin
{se o numero digitado for menor que o número do registro}
if(numero<al.numero) then
begin
{retorna o número do registro onde o ponteiro está localizado
seta a posicao do ponteiro para a posição atual}
posicao := FILEPOS(alu)-1;
i := k + 2;
end
else begin
i := i + 1;
SEEK(alu,i); //posiciona o ponteiro no registro desejado
end;
end;
end;
{ se achou for verdadeiro, então o número do aluno já está cadastrado
no arquivo, assim sendo, você não pode permitir que dois número iguais
sejam gravados para alunos diferentes }
IF achou = true THEN
WRITELN(' Já existe um aluno cadastrado com esse número ')
{ se achou for falso, então, significa que o número que será cadastrado
é diferente!}
ELSE BEGIN
IF(i = FILESIZE(alu))THEN
BEGIN
WRITELN(' Digite o numero do aluno a ser incluído ');
READLN(nome);
SEEK(alu, FILESIZE(alu));
WRITELN(' Digite o numero do aluno a ser incluido ');
READLN(numero);
WRITELN(' Digite o nome do aluno a ser incluido ');
READLN(nome);

19. WRITELN(' Digite a primeira nota a ser incluido ');
READLN(nota1);
WRITELN(' Digite a segunda nota a ser incluido ');
READLN(nota1);
al.numero := numero;
al.nome := nome;
al.nota1 := nota1;
al.nota2 := nota2;
al.media := (nota1+nota2)/2;
al.ativo := 1; //indica que este número de registro existe no arquivo
WRITE(alu, al);
WRITELN(' Aluno incluido com sucesso ');
END
ELSE BEGIN
p := FILESIZE(alu) - 1;
WHILE(p >= posicao) DO
BEGIN
SEEK(alu,p);
READ(alu,al);
WRITE(alu,al);
p := p - 1 ;
END;
SEEK(alu, posicao);
WRITELN(' Digite o numero do aluno a ser incluido ');
READLN(numero);
WRITELN(' Digite o nome do aluno a ser incluido ');
READLN(nome);
WRITELN(' Digite a primeira nota a ser incluido ');
READLN(nota1);
WRITELN(' Digite a segunda nota a ser incluido ');
READLN(nota1);
al.numero := numero;
al.nome := nome;
al.nota1 := nota1;
al.nota2 := nota2;
al.media := (nota1+nota2)/2;
al.ativo := 1; //indica que este número de registro existe no arquivo
WRITE(alu, al);
WRITELN(' Aluno incluido com sucesso ');
END;
END;
END;
READLN; //pula linha
CLOSE(alu); //fecha o arquivo
end;
BEGIN
CLRSCR; //limpa a tela

20. INSERIRALUNO();
END.