Alocação e Gerência de Memória: APONTADORES

(1)

Clesio S. Santos - Nina Edelweiss - Renata de M. Galante Estruturas de Dados - Listas Lineares

Alocação e Gerência

de Memória:

APONTADORES

Processamento – Programa Usuário

Programa

Fonte

Compilador

Programa

Objeto

Linkeditor

Módulo

Carga

Carregador

Memória

Tempo de compilação

Tempo de Carga

Tempo de Execução

Memória Principal:

visão simplificada

Memória

01

02

03 …

1000

1001

1002

1003

…

• SO carrega o programa a partir de uma

determinada posição da memória;

• Nesse espaço, variáveis declaradas

são sinônimos de endereço;

•Comandos fazem referências a

endereços, portanto, operações

referenciam esses endereços.

X = K + N

[1003] = [1001] + [1002]

50 = 45 + 5

50

5

45 • Apresentar os conceitos de alocação

dinâmica de memória

• Introduzir a utilização de variáveis do tipo

apontador

• Mostrar exemplos de apontadores em

Pascal e C

(2)

Uso de Memória

Código do

Programa

Variáveis

Globais e Estáticas

Mémória Alocada

Dinamicamente

Pilha

Memória Livre

Uso de Memória

Código do

Programa

Variáveis

Globais e Estáticas

Livre

-v

Código do

Programa

Variáveis

Globais e Estáticas

Livre

v

504 40 bytes

504 Alocação estática de memória

Programa AlocaçãoEstática;

var A : inteiro;

início

…

A := 10;

...

fim.

A

Permanece alocado

durante toda a

execução do

programa

declaração

referência

É preciso prever todo o espaço

necessário

antes

da execução do

programa

!

Alocação dinâmica de memória

Área de memória disponível

• espaço de memória alocado e liberado

durante a

execução do programa

(3)

Alocação dinâmica de memória

• erro de execução

caso não exista espaço

suficiente

• tamanho e tipo de área de memória alocada

informados no momento da solicitação

• Cuidar para não perder o endereço das variáveis

alocadas dinamicamente

• espaço é

solicitado

somente quando

necessário, e

liberado

quando não for mais

necessário

Como funcionam os PONTEIROS?

INT guarda inteiros

FLOAT guarda número de ponto flutuante

CHAR guarda caracter

PONTEIROS guardam endereços de memória

Variável Apontador

• declarada no início do programa

• associada ao tipo de dado para o qual pode

“apontar”

• comando solicita memória definindo variável

apontador que vai receber o endereço

Declaração das Variáveis

Var p:

<tipo da variável a ser alocada>

O sinal

_{faz o compilador saber que}

aquela variável não vai guardar um valor,

mas sim um endereço para aquele tipo

especificado

(4)

Declaração das Variáveis- Pascal

var p : ^int;

{p é um ponteiro para inteiros}

var x : ^float;

{x é um ponteiro para reais}

var y : ^char;

{y é um ponteiro para char}

Declaração das Variáveis- C

int *res;

/* ponteiro para uma variável inteira */

float *div;

/* ponteiro para uma variável de ponto flutuante */

Variável Apontador

• a variável do tipo apontador passa a

conter o

endereço

da área de memória

• acesso à memória através de referência do

apontador que contém seu endereço

• cuidar para não perder o endereço de

variáveis alocadas dinamicamente

Comandos

new ( < variável apontador > )

• aloca uma área correspondente a uma variável

• tipo e tamanho da área definidos pelo apontador utilizado

no comando

• endereço da variável no apontador

dispose ( < variável apontador > )

• libera a área que está sendo apontada pelo apontador

• apontador passa a conter endereço inválido

Pascal

< variável apontador > := nil

• endereço nil em um apontador significa que este não

está associado a nenhuma variável

Comandos

C

< variável apontador > = NULL

• endereço NULL em um apontador significa que este não

está associado a nenhuma variável

malloc (tamanho)

• aloca uma área de memória para um ponteiro

ptr = (int ) malloc(10 sizeof(int));

/aloca espaço para um arranjo de 10 inteiros/

free ( < variável apontador > )

• libera a área que está sendo apontada pelo apontador

• apontador passa a conter endereço inválido

(5)

Utilização - Pascal

Declaração

Var P : ^int;

Alocação

new (P);

Manipulação

P

- endereço de memória

P^ - conteúdo do endereço

Exemplos:

P^ := 10;

P := nil;

Utilização - C

Declaração

int *p;

Alocação

p = (int *) malloc(sizeof(int));

Manipulação

p = &c

-

& retorna o endereço de memória

*p

-

p é um ponteiro para inteiros, então*p

equivale a um inteiro

Exemplos:

p = &c;

p recebe o endereço de c

*p = 0

c agora é zero

program exemplo;

var p: ^integer;

begin

new(p);

p^:=10;

writeln(p^);

dispose(p);

readln;

end.

Exemplo 01

#include <stdlib.h>

#include <stdio.h>

#include <conio.h>

int main(){

int *p;

p = (int *)malloc(sizeof(int));

*p=10;

printf("%d",*p);

free(p);

getch();

}

Pascal

C

Área de memória

disponível

Exemplo 02

Programa Teste;

var PInt : ↑

↑

↑ inteiro;

início

…

aloca (PInt);

PInt ↑

↑

_{↑ := 123;}

123

456 PInt

789

789 ?

?

aloca (PInt);

PInt ↑

↑

_{↑ := 456;}

aloca (PInt);

PInt ↑

↑

↑ := 789;

escreva (PInt ↑

↑

↑);

...

fim;

(6)

program exemplo01;

var p: ^integer;

begin

new(p);

p^:=123;

new(p);

p^:=456;

new(p);

p^:=789;

writeln(p^);

readln;

end.

Exemplo 02

Pascal

C

int main(){

int *p;

p = (int *)malloc(sizeof(int));

*p=123;

p = (int *)malloc(sizeof(int));

*p=456;

p = (int *)malloc(sizeof(int));

*p=789;

printf("%d",*p);

system("PAUSE");

}

program exemplo03;

var p,x,y: ^integer;

begin

new(p);

x:=p;

y:=p;

writeln(p^);

p^:=10;

writeln('p: ',p^);

writeln('x: ',x^);

writeln('y: ',y^);

readln;

end.

Exemplo 03

Pascal

C

int main(){

int p,x,*y;

p = (int *)malloc(sizeof(int));

x=p;

y=p;

printf("%d\n",*p);

*p=10;

printf("p: %d\nx: %d\ny:%d

",p,x,*y);

system("PAUSE");

}

program exemplo04;

var p,x: ^integer;

begin

new(x);

x^:=10;

p := x;

writeln(x^);

writeln(p^);

writeln(integer(x));

writeln(integer(p));

readln;

end.

Exemplo 04

Pascal

C

int main(){

int p,x;

x = (int *)malloc(sizeof(int));

*x=10;

p = x;

printf("%d\n%d\n",x,p);

printf("%d\n%d\n",(int)x,(int)p);

system("PAUSE");

}

program exemplo05;

var p: ^integer;

i: integer;

begin

new(p);

i:=100;

p^:= i;

writeln('i: ',i);

writeln('p^: ',p^);

writeln(integer(p));

i:=40;

writeln('i: ',i);

writeln('p^: ',p^);

writeln(integer(p));

p:= addr(i);

writeln(integer(p));

i:=55;

writeln('i: ',i);

writeln('p^: ',p^);

writeln(integer(p));

readln;

dispose(p);

end.

Exemplo 05

Em Pascal

(7)

int main(){

int *p;

int i;

p = (int *)malloc(sizeof(int));

i=100;

*p= i;

printf("i: %d\np: %d\n %d\n",i, p,(int)p);

i=40;

printf("i: %d\np: %d\n %d\n",i, p,(int)p);

p= &i;

printf("%d\n",p);

i=55;

printf("i: %d\np: %d\n %d\n",i, p,(int)p);

system("PAUSE");

free(p);

}

Exemplo 05

Em C

program exemplo06;

type

pessoa = record

nome: string[30];

sexo: char;

idade:integer;

altura:real;

end;

ponteiro = ^Pessoa;

var p: ponteiro;

begin

new(p);

writeln(integer(p));

readln(p^.nome);

readln(p^.sexo);

readln(p^.idade);

readln(p^.altura);

writeln(p^.nome);

writeln(p^.sexo);

writeln(p^.idade);

writeln(p^.altura:3:2);

readln;

dispose(p);

end.

Exemplo 06

Em Pascal

typedef struct {

char nome[30];

char sexo[1];

int idade;

int altura;

}Pessoa;

int main(){

Pessoa *p;

p = (Pessoa*) malloc(sizeof(Pessoa));

printf("endereço de p %d\n",p);

printf("nome:"); scanf("%s",p->nome);

scanf("%s",p->sexo);

scanf("%d",&p->idade);

scanf("%d",&p->altura);

printf("nome: %s\n",p->nome);

printf("sexo: %s\n",p->sexo);

printf("idade: %d\n",p->idade);

printf("altura: %d\n",p->altura);

free(p);

system("PAUSE");

}

Exemplo 06

Em C

program exemplo07;

type ponteiro = ^Pessoa;

pessoa = record

nome: string[30];

elo:ponteiro;

end;

var p1,p2: ponteiro;

begin

new(p1);

new(p2);

readln(p1^.nome);

readln(p2^.nome);

p1^.elo:=p2;

writeln(p1^.elo^.nome);

writeln(p2.nome);

readln;

writeln(integer(p1));

writeln(integer(p2));

writeln(integer(p1^.elo));

writeln(integer(p2^.elo));

readln;

dispose(p1);

dispose(p2);

end.

Exemplo 07

Em Pascal

typedef struct Tpessoa{

char nome[30];

struct Tpessoa *elo;

}pessoa;

int main(int argc, char *argv[]){

pessoa *p1;

pessoa *p2;

p1 = malloc(sizeof(pessoa));

p2 = malloc(sizeof(pessoa));

scanf("%s",p1->nome);

scanf("%s",p2->nome);

p1->elo=p2;

printf("%s\n",p1->elo->nome);

printf("%s\n",p2->nome);

printf("%d\n",(int)p1);

printf("%d\n",(int)p2);

printf("%d\n",(int)p1->elo);

printf("%d\n",(int)p2->elo);

free(p1);

free(p2);

system("PAUSE");

return 0;

}

C

(8)

program exemplo07;

type ponteiro = ^Pessoa;

pessoa = record

nome: string[30];

elo:ponteiro;

end;

var p1,p2: ponteiro;

begin

new(p1);

new(p2);

readln(p1^.nome);

readln(p2^.nome);

p1.elo:=p2;

writeln(p1^.elo.nome);

writeln(p2.nome);

readln;

dispose(p1);

dispose(p2);

end.

Exemplo 08

Em Pascal

typedef struct Tpessoa{

char nome[30];

struct Tpessoa *elo;

}pessoa;

int main(){

pessoa *p1;

pessoa *p2;

p1 = (pessoa*) malloc(sizeof(pessoa));

p2 = (pessoa*) malloc(sizeof(pessoa));

scanf("%s",p1->nome);

scanf("%s",p2->nome);

p1->elo=p2;

printf("%s\n",p1->elo->nome);

printf("%s\n",p2->nome);

system("PAUSE");

free(p1);

free(p2);

system("PAUSE");

return 0;

}

Em C