Ponteiro
Inicialização de ponteiros
•
•
•
variável que armazena o endereço de uma
variável de um determinado tipo
declaração: <tipo> *<identificador>;
•
onde tipo pode ser qualquer tipo válido em C
–
Ex.: int *nota;
char *texto;
float *peso;
double *media;
//
//
//
//
ptrs ainda não
inicializados apontam p/ lugar
indefinido
1
•
•
•
pt = &x;
decl. do ptr
inicializ. - pt pode ser
usado em qualquer contexto
que x seria
int x, q, *pt;
x = 100;
pt = &x;
// pt recebe o end. de x (“aponta para”)
q = *pt;
// q recebe o conteúdo do end. de pt
Profa. Patrícia Pitthan
operador unário que obtém o conteúdo da variável
localizada no endereço que o segue (formato %p)
operador usado para declarar um ponteiro ou para obter o
conteúdo da variável apontada
Ex.:
4
int main(){
int x, q, *pt;
x = 100;
pt = &x;
// pt recebe o endereço de x
q = *pt;
// q recebe o conteúdo do end. de pt
}
Se a variável pt aponta para um endereço que contém o
valor 100, o valor de q será 100
Profa. Patrícia Pitthan
Profa. Patrícia Pitthan
Profa. Patrícia Pitthan
Ponteiros:: exemplo 1
Ponteiros
int x, q, *pt;
x = 100;
pt = &x;
// pt recebe o end. de x
q = *pt;
// q recebe o conteúdo do end. de pt
5
operador unário que obtém o endereço de memória
de uma variável (formato hexa: %X ou %x)
Se a variável x está armazenada na posição de memória
2000, o valor de pt será 2000
Ponteiros:: operador * (dereferência
Ponteiros
(dereferência))
*
Profa. Patrícia Pitthan
Ex.:
O ponteiro guarda o endereço
O endereço aponta para um valor
3
pt = NULL;
Ponteiros:: operador &
Ponteiros
Ponteiro tem 2 partes:
–
–
OU
2
&
//
//
//
//
O valor de um ponteiro é desconhecido
Para um ponteiro não apontar para um local
inválido (lixo), deve ser inicializado ou receber o
valor NULL
Ex.:
Profa. Patrícia Pitthan
Ponteiros:: declaração e inicialização
Ponteiros
int x = 10;
int *pt;
pt = &x;
Após ser declarado e antes de receber um valor
–
printf(“x = %d\n”, x);
printf(“q = %d\n”,q);
printf(“pt = %p\n”,pt); // %p – formato p/ ponteiro
printf(“pt aponta para %d\n\n”,*pt); // conteúdo da
// memória apontada por pt
x = 100
q = 100
pt = 0022FF74
pt aponta para 100
6
Profa. Patrícia Pitthan
1
Ponteiros:: exemplo 2
Ponteiros
Atribuições com Ponteiros
i = 9
&i = 22FF74
p = 0022FF74
*p = 9
&p = 22FF70
q = 0022FF74
*q = 9
&p = 22FF6C
int main(){
int i, *p, *q;
i = 9;
p = &i; // p aponta para i
q = p;
// q também aponta para i
printf("i = %d \n",i);
// valor de i
printf("&i = %X\n", &i); // end de i
printf("p = %p \n", p); // end apontado
printf("*p = %d\n", *p); // cont. do end apontado por p
printf("&p = %X\n", &p); // end de p
printf("q = %p \n", q); // end apontado
printf("*q = %d\n", *q); // cont. do end apontado por q
printf("&q = %X\n", &q); // end de q
}
7
• Como qualquer variável, um ponteiro pode ser usado no
lado direito de um comando de atribuição, passando seu
valor para outro ponteiro
– Ex.:
int x, *p1, *p2;
p1 = &x;
//p1 aponta para x
p2 = p1;
//p2 recebe p1 e tb aponta p/ x
printf(“%p”, p2);
//escreve o end. de x
Profa. Patrícia Pitthan
8
Profa. Patrícia Pitthan
Atribuições com Ponteiros
Ponteiros:: exemplo
Aritmética de Ponteiros
int main(){
int a, *x,*y;
a = 10;
x = &a;
y = x;
printf("*x = %d, *y
printf("x = %p, y =
*x = 20;
printf("*x = %d, *y
printf("x = %p, y =
}
*x = 10, *y = 10
x = 0022FF74, y =
*x = 20, *y = 20
x = 0022FF74, y =
• Ao ser incrementado, o ptr passa a apontar p/ a
posição de memória do próximo elemento do seu
tipo base
• Ao ser decrementado, o ptr passa a apontar p/ a
posição de memória do elemento anterior do seu
tipo base
• O valor do ponteiro irá aumentar ou diminuir
dependendo do nro de bytes que o tipo base
ocupa
= %d \n", *x, *y);
%p\n\n", x, y);
= %d \n", *x, *y);
%p\n\n", x, y);
0022FF74
0022FF74
9
Profa. Patrícia Pitthan
Aritmética de Ponteiros
10
Profa. Patrícia Pitthan
Aritmética de Ponteiros
• Adição e subtração de ponteiros
– Se p1 é um ptr p/ inteiro com valor inicial 2000
– Cada inteiro ocupa 2 bytes
– Após o comando p1++, o valor de p1 passa a ser 2002 (p1
passa a apontar para o próximo inteiro)
– Idem para decremento (p1--)
int *pi = 3000;
char *pc = 4000;
double *pd = 5000;
pi++;
pc++;
pd++;
// int ocupa 4 bytes
// char ocupa 1 byte
// double ocupa 8 bytes
// pi apontará p/ end. 3004
// pc apontará p/ end. 4001
// pd apontará p/ end. 5008
• Soma e subtração de inteiros de ponteiros
p1 = p1+10;
//faz p1 apontar para o 10º
elem. do tipo p1 (adiante do
elem. atualmente apontado por p1)
11
Profa. Patrícia Pitthan
Profa. Patrícia Pitthan
12
Profa. Patrícia Pitthan
2
Aritmética de Ponteiros
Ponteiros:: na memória
int x, *p;
x = 10;
p = &x;
p++;
Aritmética de Ponteiros (1a)
int x,*y;
• “x” e “y” ocupam 4 bytes consecutivos
cada
• “x” (“y”) inicia no endereço 1000
(1004) e termina no endereço 1003
(1007)
• O endereço de “x” (“y”) é 1000 (1004)
• Os valores iniciais de “x” e de “y” são
indeterminados
• “x” é do tipo inteiro e “y” é do tipo
ponteiro para inteiro
13
Profa. Patrícia Pitthan
Aritmética de Ponteiros (1b)
15
14
Profa. Patrícia Pitthan
Aritmética de Ponteiros (1c)
Profa. Patrícia Pitthan
Aritmética de Ponteiros (2a)
16
Profa. Patrícia Pitthan
Aritmética de Ponteiros (2b)
int x,*y,*z;
• “x” é do tipo inteiro
• “y” é do tipo ponteiro para inteiro
• “z” é do tipo ponteiro para inteiro
17
Profa. Patrícia Pitthan
Profa. Patrícia Pitthan
18
Profa. Patrícia Pitthan
3
Aritmética de Ponteiros (2c)
Aritmética de Ponteiros (3a)
int x,*y,**z;
• “x” é do tipo inteiro
• “y” é do tipo ponteiro para inteiro
• “z” é do tipo ponteiro para ponteiro
para inteiro
19
Profa. Patrícia Pitthan
Aritmética de Ponteiros (3b)
21
Profa. Patrícia Pitthan
Profa. Patrícia Pitthan
Aritmética de Ponteiros (3c)
Profa. Patrícia Pitthan
Aritmética de Ponteiros (3d)
23
20
22
Profa. Patrícia Pitthan
Aritmética de Ponteiros (Resumo
Resumo))
Profa. Patrícia Pitthan
Operação
Exemplo
Atribuição
int *p,*q;
p=&x;
q=p;
Obs
Incremento
p++;
p=p+2;
p aponta p/ próx. valor do mesmo tipo
incremento de 2*sizeof(tipo) de p
Decremento
p--;
p=p-4;
p aponta p/ valor anterior do mesmo tipo
decremento de 4*sizeof(tipo) de p
Apontado por
*p
conteúdo da posição apontada por p
Endereço de
&p
endereço de p
Diferença
p-q
nro de elementos entre p e q
Comparação
p > q
ptr que aponta p/ posição mais alta na
memória
p e q apontam para x
24
Profa. Patrícia Pitthan
4