Avançado - Ponteiros

Um endereço de memória é um número que serve para identificar um byte específico da memória.
Podemos imaginar a memória como sendo um vetor onde cada elemento é um byte, acessível através
de um número que é seu endereço.
Normalmente usamos variáveis para armazenar dados (caracteres, inteiros, reais, etc.). Se um endereço
é também um número, nada impede que possamos criar também variáveis para armazenar endereços
de memória. Estas variáveis são denominadas ponteiros.
Antes de se utilizar ponteiros, precisamos definir seu tipo.
type
Nome da variavél ponteiro = ^Tipo de dados;
* Sendo tipo de dados um record, um vetor, uma variável, outro tipo, etc.
Exemplo:
type
Dados = Record
Nome:String;
Idade:Integer;
End;
PtrDados = ^Dados;
Após definido um tipo, pode-se criar variáveis desse tipo.
Exemplo:
var PDados:PtrDados;
* Se uma variável ponteiro P armazena um endereço de memória qualquer, então P^ nos dá o conteúdo
armazenado naquele endereço.
Exemplo:
PDados^ - É um record
PDados^.Nome - É uma string de caracteres
PDados^.Idade - É um número inteiro
Funções Pascal para Ponteiros
New (Tipo Ponteiro);
Aloca uma área de memória e guarda seu endereço em P.
Dispose (Tipo Ponteiro);
Serve para liberar a área de memória cujo endereço está em P.
* Sendo que uma área de memória alocada por New, só estará disponível de novo, se for usado o
comando Dispose ou quando a utilização desse área for terminada.

Avançado - Estruturas de Dados - Pilha

Uma pilha é uma lista linear onde as operações de inserção e retirada são efetuadas apenas em uma
extremidade da lista linear, ou seja:
- A inserção de um elemento X torna-o o último elemento da lista;
- A retirada é sempre efetuada sobre o elemento An.
Devido às características das operações da pilha, o último elemento a ser inserido será o primeiro a ser
retirado. Estruturas desse tipo são conhecidas como "LIFO" (last in, first out).
Rotinas para Pilha
type
Tipo = Integer;
Pilha = record
P:Array [1..20] of Tipo;
Base, topo:Integer;
Maxtopo:Integer;
end;

procedure InicializaPilha(var P:Pilha);

begin
P.Base:=0;
P.Topo:=0;
P.Maxtopo:=20;
end;

procedure InserePilha(var P:Pilha;valor:Tipo);

begin
if P.topo = P.Maxtopo
then writeln('OVERFLOW')
else begin
P.Topo:=P.topo +1;
P.p[P.Topo]:=Valor;
end;
end;

function PilhaVazia(var P:Pilha):Boolean;

begin
if P.Topo = 0
then PilhaVazia:=True
else PilhaVazia:=False;
end;

function Topopilha(P:Pilha):Tipo;
begin
if not (PilhaVazia(P))
then Topopilha:=P.p[P.Topo];
end;

function Removepilha(var P:Pilha):Tipo;

begin
if P.Topo = 0
then writeln('UNDERFLOW')
else begin
Removepilha:=P.p[P.topo];
P.topo:=P.topo - 1;
end;
end;

Avançado - Estruturas de Dados - Fila

Uma fila é uma lista linear onde as operações de inserção são efetuadas apenas no final da lista e as
retiradas apenas no início da lista linear, ou seja:
- A inserção de um elemento X torna-o o último elemento da lista linear;
- A retirada é sempre efetuada sobre o elemento A1.
Devido às características das operações da fila, o primeiro elemento a ser inserido será o primeiro a ser
retirado. Estruturas desse tipo são conhecidas como "FIFO" (first in, first out).
Rotinas para Fila
const Tamanho = 20
Type Fila = record
f: array[1..tamanho] of integer;
frente, tras, MAXFILA: integer;
end;
Procedure InitFila(var f: Fila);
begin
f.frente := 0;
f.tras := 0;
f.MAXFILA := tamanho;
end;

Procedure InsereFila(var f: Fila; valor: integer);

var pos: integer;
begin
pos := (f.tras mod f.MAXFILA) + 1;
if pos = f.frente
then writeln('Overflow')
else begin
f.tras := pos;
f.f[f.tras] := valor;
if f.frente = 0
then f.frente := 1;
end;
end;

Function RemoveFila(var f:Fila): integer;

begin
if f.frente = 0
then writeln('UNDERFLOW')
else begin
RemoveFila := f.f[f.frente];
if f.frente = f.tras
then begin
f.frente := 0;
f.tras := 0;
end
else f.frente:=f.frente mod f.MAXFILA + 1;
end;
end;

function filaVazia(f: Fila): boolean;

begin
if f.frente = 0
then filaVazia := TRUE
else filaVazia := FALSE;
end;
Avançado - Estruturas de Dados - Listas Encadeadas

Em listas implementadas através de alocação seqüêncial de memória, a própria sucessão dos endereços
de memória nos dá a seqüência dos nós na estrutura.Para listas encadeadas, para manter a seqüência
dos nós precisamos acrescentar ao nó a informação de onde está o próximo nó na seqüência, ou seja, o
seu endereço.
Rotinas para Listas Encadeadas
type
PtrNodoLista = ^NodoLista;
Nodolista = Record
Conteudo:Integer;
Proximo:PtrNodoLista;
End;
procedure InicializaLista (var l:PtrNodoLista);
begin
l:=nil;
end;

procedure InsereInicioLista (var l:PtrNodoLista;x:Integer);

var P:PtrNodoLista;
begin
New(P);
p^.Conteudo:=x;
p^.Proximo:=l;
l:=p;
end;

procedure InsereFinalLista (var l:PtrNodoLista;x:Integer);

var p,ptr:PtrNodoLista;
begin
new(p);
p^.conteudo:=x;
p^.proximo:=nil;
if l = nil
then l:=p
else begin
ptr:=l;
while (ptr^.proximo <> nil) do
ptr:=ptr^.proximo;
ptr^.proximo:=p;
end;
end;

procedure InsereOrdenadoLista (var l:PtrNodoLista;x:Integer);

var p,ptr,ant:PtrNodoLista;
begin
new(p);
p^.Conteudo := x;
ptr := l;
while (ptr <> NIL) and (ptr^.Conteudo < x) do
begin
ant:=ptr;
ptr:=ptr^.proximo;
end;
if ptr = l
then l:=p
else ant^.proximo := p;
p^.Proximo := ptr;
end;

procedure ImprimeLista (l:PtrNodoLista);

var ptr:PtrNodoLista;
begin
ptr:=l;
while ptr <> nil do
begin
write(ptr^.conteudo, ' ');
ptr:=ptr^.proximo;
end;
writeln;
end;

procedure ApagaLista (var l:PtrNodoLista);

var aux,ptr:PtrNodoLista;
begin
ptr := l;
while ptr <> NIL do
begin
aux:=ptr;
ptr:=ptr^.Proximo;
dispose(aux);
end;
l:=nil;
end;

function PesquisaLista (l:PtrNodoLista;x:Integer):Boolean;

var Ptr:PtrNodoLista;
Achou:Boolean;
begin
ptr:=l;
Achou:=False;
while (ptr <> nil) and not(achou) do
begin
if ptr^.conteudo = x
then achou:=True
else achou:=False;
ptr:=ptr^.proximo;
end;
PesquisaLista:=Achou;
end;

function Listavazia (l:PtrNodoLista):Boolean;

var ptr:PtrNodoLista;
begin
ptr:=l;
if ptr = nil
then Listavazia:=True
else Listavazia:=False;
end;
function RemoveIniciolista(var l:PtrNodoLista;var x:Integer):Boolean;
begin
if Listavazia(l)
then RemoveInicioLista:=False
else if l^.proximo = nil
then begin
x:=l^.conteudo;
l:=nil;
RemoveInicioLista:=True;
end
else begin
x:=l^.conteudo;
l:=l^.proximo;
RemoveInicioLista:=True;
end;
end;

function RemoveFinallista(var l:PtrNodoLista;var x:Integer):Boolean;

var Ptr:PtrNodoLista;
begin
ptr:=l;
if Listavazia(ptr)
then RemoveFinalLista:=False
else if (ptr^.proximo = nil)
then begin
x:=ptr^.conteudo;
ptr:=nil;
RemoveFinalLista:=True;
end
else begin
while ((ptr^.proximo)^.proximo <> nil) do
ptr:=ptr^.proximo;
x:=(ptr^.proximo)^.conteudo;
ptr^.proximo:=nil;
RemoveFinalLista:=True;
end;
end;

function RemoveElementoLista(var l:PtrNodoLista;x:Integer):Boolean;

var Ptr:PtrNodoLista;
achou,btemp:Boolean;
temp:Integer;
begin
Achou:=False;
Ptr:=l;
if PesquisaLista(ptr,x)
then begin
while ptr^.proximo <> nil do
ptr:=ptr^.proximo;
if (ptr^.proximo = nil) and (ptr^.conteudo = x)
then btemp:=RemoveFinalLista(l,temp);
if (l^.proximo = nil) or (l^.conteudo = x)
then btemp:=RemoveInicioLista(l,temp);
ptr:=l;
while ((ptr^.proximo)^.proximo <> nil) and not(Achou) do
if (ptr^.proximo)^.conteudo = x
then begin
achou:=True;
ptr^.proximo:=(ptr^.proximo^).proximo;
end
else ptr:=ptr^.proximo;
RemoveElementoLista:=True;
end
else RemoveElementoLista:=False;
end;

Avançado - Estruturas de Dados - Pilha (Usando ponteiros)

Rotinas para Pilha

type
ptr = ^recdata;
recdata = record
dado : integer;
lig : ptr;
end;
Pilha = ptr;
procedure InitPilha (var topo: pilha);
begin
topo := nil;
end;

function PilhaVazia (topo: pilha): boolean;

begin
if topo = nil
then PilhaVazia := TRUE
else PilhaVazia := FALSE;
end;

procedure InserePilha (var topo: pilha; valor: integer);

var auxPtr: ptr;
begin
new(auxPtr);
auxPtr^.dado := valor;
auxPtr^.lig := topo;
topo := auxPtr;
end;

function TopoPilha (topo: Pilha): integer;

begin
if not(PilhaVazia(topo))
then topoPilha := topo^.dado;
end;

function RemovePilha (var topo: pilha): integer;

var auxPtr: ptr;
begin
if not(PilhaVazia(topo))
then begin
RemovePilha := topo^.dado;
auxPtr := topo;
topo := topo^.lig;
dispose(auxPtr);
end
else RemovePilha := 0;
end;

Avançado - Estruturas de Dados - Fila(Usando ponteiros)

Rotinas para Fila

type
ptr = ^recdata;
recdata = record
dado : integer;
lig : ptr;
end;
Fila = ptr;
procedure InitFila (var f, t: Fila);
begin
f := nil;
t := nil;
end;

function FilaVazia (f: Fila): boolean;

begin
if f = nil
then FilaVazia := TRUE
else FilaVazia := FALSE;
end;

procedure InsereFila (var f, t: Fila; valor: integer);

var auxPtr: ptr;
begin
new(auxPtr);
auxPtr^.dado := valor;
auxPtr^.lig := nil;
if t = nil
then f := auxPtr
else t^.lig := auxPtr;
t := auxPtr;
end;

function RemoveFila (var f, t: Fila): integer;

var auxPtr: ptr;
begin
if not(FilaVazia(f))
then begin
RemoveFila := f^.dado;
auxPtr := f;
f := f^.lig;
if f = nil
then t := nil;
dispose(auxPtr);
end
else Removefila := 0;
end;
Avançado - Arquivos

Arquivos Binários
Arquivos do tipo binário usam o sistema binário de numeração para armazenar tanto as informações
numéricas quanto as informações literais, estas últimas através de códigos numéricos dos seus
caracteres (ASCII).
Na linguagem Pascal a organização dos arquivos binários é sempre seqüencial, isto é, os registros são
colocados um após o outro, em seqüência. Quanto ao acesso, embora a linguagem Pascal só
estabeleça o acesso seqüencial dos arquivos binários, as suas implementações geralmente também
permitem o seu acesso direto, através do número de ordem do registro.
Declaração de Arquivos Binários
type
nome do tipo = File of tipo do registro;
var lista de identificadores: nome do tipo;
Exemplo:
type
ArqInt = File of Integer;
var Notas: ArqInt;

Arquivos Textos
Arquivos do tipo texto armazenam todas as informações, numéricas ou literais, através de códigos de
seus caracteres (geralmente ASCII). Por exemplo, o valor numérico 65 é armazenado através dos
caracteres '6' e '5', cujos códigos ASCII são 54 e 53.
Os caracteres de um arquivo tipo texto (ou os seus códigos) são agrupados em linhas, que por sua vez
são agrupadas em páginas. O caractere de código 13 (#13) indica o fim da linha, o de código 12 (#12) o
fim da página e o código 26 (#26) o fim do arquivo. Por exemplo se faço write(Arq,#13); estou criando
uma quebra de linha no arquivo.
* A organização dos arquivos textos no Pascal assim como os arquivos binários também é seqüencial,
mas não permite o acesso direto aos elementos do arquivo.

Declaração de Arquivos Textos

type
nome do tipo = Text;
var lista de identificadores: nome do tipo;
Exemplo:
type
ArqText = Text;
var Notas: ArqText;

Para a manipulação de arquivos:

- Associar uma variável-apontador para o arquivo;
- Abrir o arquivo;
- Comandos a serem realizados no arquivo;
- Fechar o arquivo;
Abertura de Arquivos
Assign (variavel do tipo arquivo,nome externo);
* Variavel do tipo arquivo - Pode ser uma variável para arquivos do tipo binário ou para arquivos do tipo
texto.
* Nome externo - Nome e/ou caminho onde está o arquivo gravado no HD
Exemplo:
var ArqText: Text;
ArqBin: File of Integer;
begin
assign (ArqText,'ArquivoTexto.txt'); { Associa a uma variável para um arquivo do tipo texto ao arquivo
"ArquivoTexto.txt". }
assign (ArqBin,'ArquivoBinario.bin'); { Associa a uma variável para um arquivo do tipo binário ao arquivo
"ArquivoBinario.txt". }
end.
• Reset (variável do tipo arquivo);
Para abrir um arquivo do tipo texto ou binário para somente leitura.
• Append (variável do tipo arquivo texto);
Para abrir um arquivo para inserção, sendo que a inserção irá continuar após o último dado inserido no
arquivo.
* Apenas para arquivos texto.
• Rewrite (variável do tipo arquivo);
Caso o arquivo ainda não tenha sido criado, é criado um arquivo (especificado no assign) caso contrário
se o arquivo já existir ele é sobrescrito e é colocado no modo de inserção.
Exemplo de uma abertura de arquivo:
assign(Arq,'Arqbin.bin');
reset(Arq);
Associa um arquivo do tipo binário a variável Arq, e abre o arquivo para somente leitura.
Fechamento de Arquivos
Close (variável do tipo arquivo);
Fecha o arquivo.

Leitura de Arquivos
• read (variável do tipo arquivo, variável que irá receber o valor lido);
Exemplo:
var Arq: File of Integer;
Num:Integer;
begin
assign (Arq,'ArqBin.bin');
reset (Arq);
read (Arq, num);
close (Arq);
end.
• readln (variável do tipo arquivo, variável que irá receber o valor lido);
Exemplo:
var Arq: Text;
Linha:String;
begin
assign (Arq,'ArqText.txt');
reset (Arq);
readln (Arq, linha);
close (Arq);
end.
* O comando read e readln podem ser usados para arquivos do tipo texto, mas para arquivos do tipo
binário só se pode usar o comando read.

Escrita de Arquivos
• write (variável do tipo arquivo, variável que contém o valor a ser gravado);
Exemplo:
var Arq: File of Integer;
Num:Integer;
begin
num:=10;
assign (Arq,'ArqBin.bin');
reset (Arq);
write (Arq, num); { É gravado o número 10 num arquivo binário }
close (Arq);
end.
• writeln (variável do tipo arquivo, variável que contém o valor a ser gravado);
Exemplo:
var Arq: Text;
Linha:String;
begin
linha:='Teste de Arquivos';
assign (Arq,'ArqText.txt');
rewrite (Arq); { Cria um arquivo "ArqText.txt" e o deixa em modo de inserção }
writeln (Arq, linha); { É gravado a string "Teste de Arquivos" no arquivo texto }
close (Arq);
end.
* O comando write e writeln podem ser usados para arquivos do tipo texto, mas para arquivos do tipo
binário só se pode usar o comando write.

Funções Auxiliares
Arquivos Arquivos
Nome Utilização
Binários Textos
Seek (variável do tipo Posiciona o registro do apontador
arquivo,número do para o número de registro Sim Não
registro); especificado.
FileSize (variável do Retorna o número total de
Sim Não
tipo arquivo); registros de um arquivo binário.
Retorna TRUE quando o
EOF (variável do tipo
apontador chega no final do Sim Sim
arquivo );
arquivo.
Retorna TRUE quando o
EOLN (variável do tipo
apontador chega no final da linha Sim Sim
arquivo);
do arquivo.