Algoritmos e Estruturas de Dados I – Ponteiros Profa. Mercedes Gonzales Márquez

Variáveis (relembrando) Variável é um nome amigável (simbólico) que damos para uma localização de memória que receberá um dado de algum tipo. No momento da declaração de uma variável, um espaço de memória é alocado para ela. Nome (rótulo) Variável: Valor (conteúdo)   2047 Endereço na memória Conteúdo Nome prsqprsq inteiro: p,q,s real: r p ←50 r ←40.5

Ponteiros - Conceito Um ponteiro é uma variável que armazena um endereço de memória   Endereço na memória Conteúdo Nome prsqprsq O nome ponteiro refere ao fato deste tipo especial de variável “apontar” para um endereço. inteiro: p,r,*q real: r p ←50 r ←40.5 q ←&p O símbolo & representa o endereço. O símbolo * indica que q é um ponteiro.

Ponteiros - Declaração Ponteiro tem um tipo associado que determina o tipo da dado contido no endereço apontado. Pode ser um tipo pré-definido da linguagem ou um tipo definido pelo programador. Exemplo: inteiro, literal, real, TipoProduto,etc. A declaração de um tipo ponteiro se faz com a seguinte sintaxe: tipo da dado apontado: *ponteiro Exemplos: Real: *p1 Inteiro: *p2 Literal: *p3

Operadores indireção e endereço O símbolo * é chamado operador de indireção. Se aplicado a um ponteiro, ele indica o valor armazenado no endereço contido no ponteiro. O símbolo & é conhecido como operador endereço. Anexado no início de um nome de variável, ele representa o endereço na memória onde o valor da variável está armazenado. inteiro: cont ← 10, x, *p p ← &cont x ← *p escreva (cont,x); Endereço na memória Conteúdo cont p x  

Ponteiros – Operador & Considere as declarações e inicializações inteiro: x, y, *p1, *p2 x ← -42 y ← 163 Essas declarações alocam memória para duas variáveis do tipo inteiro e duas do tipo ponteiro a inteiro. Os seus valores serão armazenados nos endereços de memória indicados no seguinte diagrama.

Ponteiros – Operador & Se fizermos: p1 ← &x p2 ← &y Teremos a memória no seguinte estado. p1 e p2 apontam as variáveis que estão referenciando. antesdepois

Ponteiros – Operador * Se fizermos: *p1 ← 17 muda o valor na variável x devido que é onde p1 aponta. Assim, teremos a seguinte configuração.

Ponteiros – Atribuindo outro ponteiro Também é possível atribuir novos valores aos ponteiros. Por exemplo p1 ← p2 leva ao computador a tomar o valor contido na variável p2 (1004) e copiá-lo na variável p1. Ao copiar este valor em p1, ambos p1 e p2 apontarão à variável y, como mostramos no diagrama: 1004

Ponteiros – Atribuindo valores Resumindo, nós podemos atribuir valores para um ponteiro de duas formas: – Usando o operador endereço int *p; int x; p = &x; *p = 4; – Usando diretamente atribuição entre ponteiros. int *p; int *p1; int x; p1 = &x; p = p1; *p = 4; Em ambos os casos estamos referenciando alguma variável.

Ponteiros – Apontando para lixo int *p; *p = 4; Observe o seguinte exemplo: O ponteiro p foi declarado, mas não lhe foi atribuído nenhum valor, ou seja p aponta a um endereço desconhecido (comumente chamado lixo). Quando o valor 4 é armazenado na localização que p aponta, nós não podemos saber onde o valor 4 será armazenado. Tentar acessar este valor pode gerar um erro fatal no nosso programa ou até sistema operacional.

Ponteiros – Constante NULO Os valores de um ponteiro: – Um ponteiro a alguma outra variável. – Pode ser atribuído uma constante NULO Um ponteiro nulo não aponta a posição alguma. É uma boa prática testar se o ponteiro é nulo antes de indagar sobre o valor apontado. inteiro: *ip ← NULO; se (ip <>NULO) escreva (*ip) Se (ip ) escreva(*ip)

Ponteiros e arrays Nome de array é um apontador – int a[6]; int a2[6]; Passagem de array como parâmetro é por referência – funcao(int a[]) ou funcao(int *a)// declaração – funcao(a); // chamada Operador atribuição não funciona – a ← a2; // errado! Não é possível copiar diretamente Identificador do array é o endereço 1º elemento – a é &a[0] Conteúdo do array – Conteúdo da 1ª posição: *a ou a[0] – Conteúdo da 2ª posição: *(a+1) ou a[1]

Ponteiros e arrays Assuma que Inteiro: *pa pa ← &a[0] ou pa←a Então p aponta para a[0], *(pa+1) refere ao conteúdo de a[1], pa+i é o endereço de a[i] e *(pa+i) é o conteúdo de a[i]. O valor em a[i] pode também ser escrito como *(a+i). O endereço &a[i] e a+i são também idénticos.

Ponteiros e arrays vazio print1(inteiro: vet[], inteiro: n) inteiro: i Para i de 1 até n repita escreva (vet[i]) vazio print2(inteiro: vet[],int n) inteiro: * ptr Para ptr de vet até vet+n repita escreva (*ptr) vazio print3(inteiro: *vet,inteiro: n) Inteiro: * ptr Para ptr de vet até vet+n repita escreva (*ptr); } vazio print4(inteiro: *vet,inteiro: n) Inteiro: i Para i de 1 até n repita escreva (*vet) vet<-v+1 Os elementos de um array podem ser acessados através de índices como de ponteiros. Exemplo:

Alocação estática Até agora, todas as estruturas tinham tamanho pré- definido, exemplo matrizes e vetores. Esta alocação estática pode implicar em: – desperdício dos recursos pois podemos definirmos um tamanho muito maior que aquele que normalmente será usado em tempo de execução. – Pode-se, em contraste, subestimar o tamanho necessário para armazenar os dados.

Alocação dinâmica Na alocação dinâmica os espaços são alocados durante a execução do programa, conforme este necessitar de memória. Não há reserva antecipada de espaço. Alocar memória dinamicamente significa gerenciar memória (isto é, reservar, utilizar e liberar espaço) durante o tempo de execução.

Ponteiros – Alocação dinâmica Alocando espaço na Heap O uso mais importante de ponteiros é para apoio à alocação dinâmica, isto é, ao invés de apontar variáveis já alocadas do espaço de dados, utilizar o espaço de heap para novas variáveis, que podem ser liberadas após o uso, mesmo antes do término do programa. Para isso, é necessária uma operação de alocação de memória, e uma para liberação de memória.

Ponteiros – Alocação dinâmica A operação que aloca memória é implementada por uma função, na forma: aloque(p) Esta operação reserva, na Heap, espaço suficiente para armazenar um dado do tipo apontado por p. Em p é armazenado o endereço de memória deste dado. A operação que libera memória é implementada por uma função, na forma: libere(p) Esta operação ‘retorna’ para a Heap aquele espaço ocupado pelo dado apontado por p, e anula p.

Ponteiros ou Apontadores Após a alocação o ponteiro passará apontar para uma área definida da memória capaz de armazenar uma variável de determinado tipo.Exemplo: real:*p1 inteiro:*p2 literal: *p3 aloque(p1) aloque (p2) aloque (p3)

Ponteiros ou Apontadores Exemplo 1: inteiro:*p2 aloque(p2) *p2 ←‘ a’ (errado) *p2 ←5 (certo)

Ponteiros ou Apontadores Exemplo 2: inteiro:*p2 *p2 ←5 (erro, o ponteiro não foi alocado) No seguinte exemplo atribuimos o valor nulo para um ponteiro, a fim de indicar que ainda não foi alocado espaço para ele. real:*ap1 ap1 ←NULO

Ponteiros ou Apontadores Exemplo 3: inteiro: *p2 aloque (p2) *p2 ←5 libere (p2)

Ponteiros ou Apontadores Exemplo 4: Inteiro:x, *p,*q x ← 1 p ← &x *q ← 3 q ← p *q ← *p + 1 escreva(*p) Teste de mesa inicial p x q lixo

Ponteiros ou Apontadores Exemplo 4: Inteiro:x, *p,*q x ← 1 p ← &x *q ← 3 q ← p *q ← *p + 1 escreva(*p) p x q lixo 1

Ponteiros ou Apontadores Exemplo 4: Inteiro:x, *p,*q x ← 1 p ← &x *q ← 3 q ← p *q ← *p + 1 escreva(*p) p x q 1 lixo

Ponteiros ou Apontadores Exemplo 4: Inteiro:x, *p,*q x ← 1 p ← &x *q ← 3 q ← p *q ← *p + 1 escreva(*p) p x q 1 lixo ERRO, q aponta para lixo

Ponteiros ou Apontadores Exemplo 4: Inteiro:x, *p,*q x ← 1 p ← &x *q ← 3 q ← p *q ← *p + 1 escreva(*p) p x q 1

Ponteiros ou Apontadores Exemplo 4: Inteiro:x, *p,*q x ← 1 p ← &x *q ← 3 q ← p *q ← *p + 1 escreva(*p) p x q 2

Ponteiros ou Apontadores Exemplo 4: Inteiro:x, *p,*q x ← 1 p ← &x *q ← 3 q ← p *q ← *p + 1 escreva(*p) p x q 2 Resultado = 2

Ponteiros ou Apontadores Exemplo 4: Alocação dinâmica Inteiro:*p,*q aloque(p) *p ← 1 q ← p *q ← *p + 1 escreva(*p) libere(p) Teste de mesa inicial p q lixo

Ponteiros ou Apontadores Exemplo 4: Alocação dinâmica Inteiro:*p,*q aloque(p) *p ← 1 q ← p *q ← *p + 1 escreva(*p) libere(p) q lixo

Ponteiros ou Apontadores Exemplo 4: Alocação dinâmica Inteiro:*p,*q aloque(p) *p ← 1 q ← p *q ← *p + 1 escreva(*p) libere(p) q lixo

Ponteiros ou Apontadores Exemplo 4: Alocação dinâmica Inteiro:*p,*q aloque(p) *p ← 1 q ← p *q ← *p + 1 escreva(*p) libere(p) p q 1 lixo

Ponteiros ou Apontadores Exemplo 4: Alocação dinâmica Inteiro:*p,*q aloque(p) *p ← 1 q ← p *q ← *p + 1 escreva(*p) libere(p) q p q 1

Ponteiros ou Apontadores Exemplo 4: Alocação dinâmica Inteiro:*p,*q aloque(p) *p ← 1 q ← p *q ← *p + 1 escreva(*p) libere(p) q p q 2

Ponteiros ou Apontadores Exemplo 4: Alocação dinâmica Inteiro:*p,*q aloque(p) *p ← 1 q ← p *q ← *p + 1 escreva(*p) libere(p) Resultado = 2 q p q 2

Ponteiros ou Apontadores Exemplo 4: Alocação dinâmica Inteiro:*p,*q aloque(p) *p ← 1 q ← p *q ← *p + 1 escreva(*p) libere(p)

Ponteiros ou Apontadores Exemplo 4: Alocação dinâmica Inteiro:*p,*q aloque(p) *p ← 1 q ← p *q ← *p + 1 escreva(*p) libere(p) Para evitar accidentes acrescente: q ← nulo p ← nulo

Ponteiros ou Apontadores Exemplo 5: Tipo reg: registro real:valor reg:*pont Fim_Registro reg:*p,*q,x,x1 x.valor ←10.5 p ←&x x.pont ←&x1 Teste de mesa inicial p q lixo

Ponteiros ou Apontadores Exemplo 5: Tipo reg: registro real:valor reg:*pont Fim_Registro reg:*p,*q,x,x1 x.valor ←10.5 p ←&x x.pont ←&x1 p q lixo

Ponteiros ou Apontadores Exemplo 5: Tipo reg: registro real:valor reg:*pont Fim_Registro reg:*p,*q,x,x1 x.valor ←10.5 p ←&x x.pont ←&x1 x1.valor ← 0,2 q ← x.pont x1.pont ← NULO p lixo Usamos o símbolo Para indicar que o ponteiro aponta para nulo

Ponteiros ou Apontadores escreva(*p.valor) escreva(*q.valor) escreva(*p.*pont.valor) escreva(x.valor) escreva(x.*pont.valor) escreva(x1.valor) p

Ponteiros ou Apontadores escreva(*p.valor) escreva(*q.valor) escreva(*p.*pont.valor) escreva(x.valor) escreva(x.*pont.valor) escreva(x1.valor) p 10,5 0,2 10,5 0,2

Ponteiros ou Apontadores Exercícios: (1) Qual é a saída de c em inteiro *p,*q,a,b,c a ←1 b ←2 p ← &a q ← &b c ← *p + *q

Ponteiros ou Apontadores Exercícios: (2) Qual é a saída de c em inteiro *p, **r,a,c,b a ←1 b ←2 p ← &a r ← &p c ← **r + b (3) Obtenha a saída do algoritmo anterior fazendo com que p e q sejam alocadas dinamicamente. Não use x nem x1.

Ponteiros ou Apontadores Exercícios: (4) Por que o algoritmo abaixo está errado? procedimento troca (inteiro: *i, *j) inteiro *temp Início *temp ← *i *i ← *j *j ← *temp Fim

Ponteiros ou Apontadores (5) Dado o seguinte algoritmo, complete as Tabelas 1 e 2. inteiro: i, j, *p_1, *p_2, **p_p_1, **p_p_2 i ← 4 j ← 5 p_1 ← &i p_2 ← &j p_p_1 ← &p_2 p_p_2 ← &p_1

Ponteiros ou Apontadores (6) Vamos criar os seguintes procedimentos: leCoordenada3D(Coordenada3d *f);: lê dados de um ponto no espaço tridimensional com coordenadas (x,y,z) passada como ponteiro. (Por quê como ponteiro?) imprimeCoordenada3D(Coordenada3d f); Imprime coordenadas de um ponto no espaço tridimensional. O programa principal que requeira a leitura de 5 pontos no espaço tridimensional. (7) Refaça o exercício 6 considerando um vetor de pontos tridimensionais de tamanho dinâmico (use aloque).