ponteiros

Prévia do material em texto

Algoritmos e Estruturas de
dados
Ponteiros
Prof. Dr. Fa´bio Rodrigues de la Rocha
(Ponteiros) 1 / 23
Como as varia´veis ficam na memo´ria ?
int 32 bits = 4 bytes
char 8 bits = 1 byte
float 32 bits=4bytes
double 64bits=8bytes
float z=3.2;
char c=’A’;
int x=1024;
0
1
2
3
5
4
6
7
8
9
#include <stdio.h>
void main (void)
{
}
(Ponteiros) 2 / 23
Ponteiros com varia´veis simples:
int count=10;
int *pt;
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
count
pt
10
Memória
(Ponteiros) 3 / 23
Ponteiros com varia´veis simples:
int count=10;
int *pt;
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
count
pt
10
pt=&count;
6
//pt=6 pois o 
//endereco inicial
//de count vale 6
Memória
(Ponteiros) 4 / 23
Ponteiros com varia´veis simples:
int count=10;
int *pt;
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
count
pt
pt=&count;
6 *pt=12;
//o conteudo da 
10 12
// a posicao 6 
// ou seja
//em pt recebe 12
//posicao armazenada
Memória
(Ponteiros) 5 / 23
�
1 #include <stdio.h>
2 void main (void)
3 {
4 int num ,valor;
5 int *p;
6 num =55;
7 p=&num; /* Pega o endereco de num */
8 valor=*p; /* Valor e igualado a num de uma
maneira indireta */
9 printf ("\n\n%d\n",valor);
10 printf ("Endereco para onde o ponteiro aponta: %p\
n",p);
11 printf ("Valor da variavel apontada: %d\n" ,*p);
12 }� �
(Ponteiros) 6 / 23
Mas e ponteiros para varia´veis do tipo vetor ?
(Ponteiros) 7 / 23
�
1 main ()
2 {
3 float matrx [50][50];
4 float *p;
5 int count;
6 p=&matrx [0][0];
7 for (count =0;count <2500; count ++)
8 {
9 *p=0.0;
10 p++;
11 }
12 }� �
(Ponteiros) 8 / 23
Mas por que isso e´ poss´ıvel ?
(Ponteiros) 9 / 23
Estruturas. Exemplo que na˜o funciona como previsto.
(Ponteiros) 10 / 23
�
1 #include <stdio.h>
2 struct Teste {
3 int codigo;
4 int CPF;
5 };
6 void muda_CPF ( struct Teste xx) {
7 xx.CPF = 100;
8 }
9 void main (void)
10 {
11 struct Teste T;
12
13 T.codigo =123;
14 T.CPF =34;
15 muda_CPF(T);
16 printf("CPF=%d\n",T.CPF);
17 }� �
(Ponteiros) 11 / 23
Exemplo modificado para funcionar corretamente
(Ponteiros) 12 / 23
�
1 #include <stdio.h>
2 struct Teste {
3 int codigo;
4 int CPF;
5 };
6 void muda_CPF ( struct Teste *xx) {
7 (*xx).CPF= 100;
8 }
9 void main (void)
10 {
11 struct Teste T;
12
13 T.codigo =123;
14 T.CPF =34;
15 muda_CPF (&T);
16 printf("CPF=%d\n",T.CPF);
17 }� �
(Ponteiros) 13 / 23
A notac¸a˜o (*xx).CPF assusta algumas pessoas, por isso, existe uma
notac¸a˜o equivalente xx->CPF
(Ponteiros) 14 / 23
�
1 #include <stdio.h>
2 struct Teste {
3 int codigo;
4 int CPF;
5 };
6 void muda_CPF ( struct Teste *xx) {
7 xx->CPF= 100;
8 }
9 void main (void)
10 {
11 struct Teste T;
12
13 T.codigo =123;
14 T.CPF =34;
15 muda_CPF (&T);
16 printf("CPF=%d\n",T.CPF);
17 }� �
(Ponteiros) 15 / 23
Ponteiros gene´ricos
Voceˆ reparou que as varia´veis ponteiro sempre tem um tipo ? Assim,
se preciso trabalhar com um nu´mero float e utilizarei um ponteiro, o
ponteiro precisa ser do tipo float. O mesmo vale para int, long,
etc. Chamados isso de ponteiros “tipados”�
1 int *x; // ponteiro para inteiro
2 float *y; // ponteiro para real
3 long *z; // ponteiro para inteiro longo
4 char *k; // ponteiro para caractere
5 printf("inteiro =%d\n",sizeof(x));
6 printf("float =%d\n",sizeof(y));
7 printf("long =%d\n",sizeof(z));
8 printf("char =%d\n",sizeof(k));� �
(Ponteiros) 16 / 23
Ponteiros gene´ricos - parte 2
Conclusa˜o:
Ponteiros possuem sempre o mesmo tamanho. Esse tamanho esta´ ligado
ao sistema onde o co´digo foi compilado. Num compilador de 16 bits, um
ponteiro tera´ 16 bits. Num compilador de 32 bits os ponteiros tera˜o 32
bits.
(Ponteiros) 17 / 23
Ponteiros gene´ricos - parte 3
Ponteiros gene´ricos:
Chama-se ponteiro gene´rico um ponteiro que pode ser utilizado para
“apontar” para varia´veis de qualquer tipo. Representa-se assim:�
1 #include <stdio.h>
2 #include <string.h>
3 void *ponteiro; // ponteiro generico
4 float z=3.24;
5
6 void main (void) {
7 ponteiro =(void *)&z;
8 printf("Valor = %f" ,*(float *) ponteiro);
9 }� �
(Ponteiros) 18 / 23
Ponteiros gene´ricos - parte 4
Ponteiros gene´ricos:
A expressa˜o ponteiro=(void *)&z faz uma mudanc¸a forc¸ada de tipo, ou
seja, ela converte um enderec¸o de um float para um enderec¸o gene´rico.
Se ponteiros gene´ricos permitem trabalhar com varia´veis de quaisquer
tipos, por que preciso dos ponteiros “tipados”
(Ponteiros) 19 / 23
Ponteiros gene´ricos - parte 4
�
1 #include <stdio.h>
2 #include <string.h>
3
4 int vet [4]={23 ,34 ,78 ,12};
5
6 void main (void) {
7 int *ptr;
8 void * generico;
9 ptr=vet;
10 printf("terceiro elemento =%d\n" ,*(ptr+2));
11 generico =(void *) vet;
12 printf("terceiro elemento =%d\n" ,*((int *)(generico
+8)));
13 }� �
(Ponteiros) 20 / 23
Ponteiros gene´ricos - parte 5
O co´digo do slide anterior
somente funciona como
previsto pois como o ponteiro e´
tipado, ao somarmos o valor 2
ele pula para o terceiro inteiro
na sequencia. Mesmo que um
inteiro ocupe mais de 1 byte.
vet[0]=23
0
2
1
3
4
5
6
7
8
9
10
11
12
13
14
15
vet[1]=34
vet[2]=78
vet[3]=12
00000000
00000000
00000000
00010111
23= 00000000 00000000 00000000 00010111
(Ponteiros) 21 / 23
Uso Avanc¸ado - Ponteiros para func¸o˜es
�
1 #include <stdio.h>
2 #include <string.h>
3
4 void mostra_msg ( void) {
5 printf("Oi mundo\n");
6 }
7 void main (void)
8 {
9 void (*p)(void); // Declara um ponteiro
10 // para uma funcao que retorna void
11 // e que tem um parametro void
12 p=mostra_msg;// pega o endereco
13 // da funcao
14 p(); //chama indiretamente a funcao
15 }� �
(Ponteiros) 22 / 23
Uso Avanc¸ado - Ponteiros para func¸o˜es 2
�
1 #include <stdio.h>
2 void mostra_msg ( void) {
3 printf("Oi mundo\n");
4 }
5 void mostra_2 ( void) {
6 printf("Tchau mundo\n");
7 }
8 void main (void) {
9 void (*p[2])(void);
10
11 p[0]= mostra_msg;
12 p[1]= mostra_2;
13 (*p[0])(); //chama mostra_msg
14 (*p[1])(); //chama mostra_2
15 }� �
(Ponteiros) 23 / 23