Apontadores (Ponteiros)

Apontadores (Ponteiros)

Um apontador é uma variável que contém o endereço de um dado ou de um código de programa. Podemos obter o endereço de uma variável usando a função Addr ou o operador @.

A função Addr(<variável>)
O operador @<variável>

Exemplo 1: Obtendo o endereço de uma variável integer:

var N : integer;
begin
writeln('Addr(N)=', longint(Addr(N)));
writeln('@N=', longint(@N))
end.

Variável tipo Pointer

Usa-se uma variável tipo Pointer para armazenar um endereço de memória.

var <nome-da-variável> : Pointer;

Este tipo de apontador pode ser usado para guardar o endereço de qualquer variável, independente do tipo da mesma.

Exemplo 2: Atribuindo endereços de variáveis a um apontador:

var
   N : integer;
   R : real;
   S : String[50];
   P : Pointer;
begin
   P := Addr(N);   {1}
   writeln('Addr(N)=', longint(P));

   P := Addr(R);   {2}
   writeln('Addr(R)=', longint(P));

   P := @S;        {3}
   writeln('Addr(S)=', longint(P));
end.

Supondo que N, R, S e P estão juntos na memória, teríamos uma organização semelhante à abaixo:

Apontadores Tipados

São apontadores que podem ser usados para referenciar um tipo específico. São declarados da seguinte forma:

var <nome-da-variável> : ^<tipo>;

Exemplo 3: Crie um apontador para um Item que possui um nome e um preço:

type
   TItem = record
      Nome : String;
      Preco : real;
   end;
var
   PItem : ^TItem;
   Item : TItem;
begin
   Item.Nome := 'Livro de Ed1';
   Item.Preco := 25.0;
   PItem := Addr(Item);
end.

Desreferenciando um Apontador

Desreferenciar um apontador faz com que obtenhamos o valor contido no endereço apontado.

<identificador>^

A atribuição de apontadores é igual a uma variável normal.

Exemplo 4: A atribuição de apontadores é igual a uma variável normal.

var
   X : integer;
   P1, P2 : ^integer;
begin
   X := 10;
   P1 := @X;
   writeln(X);
   writeln(P1^);
   P2 := P1;
   P2^ := 100;
   writeln(X)
end.

A Constante Nil

É uma constante que representa um endereço de memória inválido, ou seja, um apontador com esse valor não aponta para nada.

Variáveis Dinâmicas

São variáveis que são criadas e destruídas durante a execução do programa (dinamicamente e sob demanda). Não são associados a um identificador. Não são declaradas na seção de declaração de variáveis. São sempre referenciadas através de apontadores.

Permitem melhor gerenciamento da memória, já que podem ser alocadas sob demanda e liberadas assim que não forem mais necessárias.

Suportam a criação de estruturas de dados complexas de forma eficiente, como listas encadeadas e árvores.

Em certas situações, são mais eficientes do que estruturas estáticas, permitindo que o programador decida qual é melhor em cada situação.

Porém, o uso de variáveis dinâmicas está associada a mais erros de programação, já que a alocação e desalocação de memória fica a cargo do programador.

Alocação e Desalocação de Variáveis Dinâmicas

Há uma função chamada new que dado um apontador cria uma variável dinâmica do tipo do apontador e faz com que o apontador tipado passado aponte para a variável criada.

new (<apontador-tipado>)

Para liberar a memória alocada pela função new, usa-se o procedimento dispose.

dispose (<apontador-tipado>)

Exemplo 5: Usando new e dispose para trabalhar com variáveis dinâmicas.

type
   TItem = record
      Nome : String[20];
      Preco : real
   end;
var
   PItem, PAnterior : ^TItem;
begin
   New(PItem);
   PItem^.Nome := 'Livro de ED1';
   PItem^.Preco := 30.0;
   PAnterior := PItem;

   New(PItem);
   PItem^.Nome := 'Outro livro';
   PItem^.Preco := 10.0;

   writeln(PAnterior^.Nome);
   writeln(PAnterior^.Preco);

   writeln(PItem^.Nome);
   writeln(PItem^.Preco);

   Dispose(PAnterior);
   Dispose(PItem);

   PItem := nil;
   PAnterior := nil
end.

Exemplo 6: Usando variáveis dinâmicas para ler e guardar na memória uma lista de itens.

type
   PItem = ^TItem;
   TItem = record
      Nome : string[20];
      Preco : real;
      Proximo : PItem
   end;
var
   Head : PItem;
   PNew : PItem;
   Resp : char;
begin
   Head := nil;

   repeat
      New(PNew);
      writeln('Digite o nome e o preco do Item:');
      readln(PNew^.Nome, PNew^.Preco);
      PNew^.Proximo := Head;
      Head := PNew;
      write('Outro Item (S/N)?');
      readln(Resp);
   until UpCase(Resp) = 'N';
end.

Alocando e Desalocando Memória usando GetMem e FreeMem

GetMem(<apontador>, <número-de-bytes>)

Aloca o número de bytes passado e faz com que o apontador contenha o endereço do primeiro deles.
É semelhante à função new, mas funciona também para apontadores to tipo pointer.

FreeMem(<apontador>, <número-de-bytes>)

Desaloca o número de bytes passado como parâmetro iniciando no endereço contido no apontador.
É semelhante à função dispose, mas funciona também para apontadores to tipo pointer.

A Lista de Blocos Livres

Ao desalocar uma variável dinâmica, normalmente cria-se um espaço vazio na memória. O endereço e o tamanho desta variável são incluídos na lista de blocos livres. As funções New e GetMem verificam se há um bloco livre na lista com o tamanho desejado.

Caso o tamanho da variável seja menor, o bloco anterior será substituído por um menor.
Se a lista não contiver um bloco do tamanho desejado, a variável dinâmica será criada no topo do heap.
Todos os blocos têm tamanho múltiplos de 8. Isso significa que mesmo variáveis com 1 byte irão usar 8 bytes.
Quando há 2 blocos adjacentes, eles são transformados em um único com o tamanho dos dois juntos.

As funções MaxAvail e MemAvail

MaxAvail retorna o tamanho do maior bloco de memória livre, incluindo o bloco que começa no topo do heap.

MemAvail retorna a soma dos tamanhos de todos os blocos livres.

Exemplo 7: Usando GetMem, FreeMem, MaxAvail e MemAvail.

var
   P : Pointer;
begin
   writeln('MaxAvail:', MaxAvail, ', MemAvail:', MemAvail);
   GetMem(P, 5000);
   writeln('MaxAvail:', MaxAvail, ', MemAvail:', MemAvail);
   FreeMem(P, 5000);
   writeln('MaxAvail:', MaxAvail, ', MemAvail:', MemAvail);
end.

Cuidados com o Dispose

Após executar Dispose o apontador continua apontado para o mesmo endereço

É uma boa prática atribuir Nil aos apontadores após chamar Dispose
Nil é uma constante que representa um endereço de memória que não é válido (nulo)
Dizemos que um apontador está aterrado quando aponta para Nil

Erros Comuns com Apontadores

Não desalocar uma variável dinâmica, fazendo com que memória seja desperdiçada.
Perder a referência para uma variável dinâmica (mudando o valor de um apontador), situação conhecida como memory leak.
Usar uma variável dinâmica desalocada, o que pode gerar erros imprevisíveis pois a área de memória já pode estar sendo usada por outra variável dinâmica.