Aula_Ponteiros

Prévia do material em texto

Ponteiros 
Ponteiros (ou apontadores) 
 Uma variável que contém o endereço de 
memória de outra variável 
– em geral, um inteiro positivo 
 
 Recurso poderoso 
 
 Torna o código mais eficiente 
– Compilação mais rápida 
 
 
Ponteiros 
 Na linguagem C é usado para: 
 Passagem de parâmetros em funções 
(passagem por referência) 
 Alternativa para acessar vetores e 
matrizes 
 Estruturas de dados dinâmicas 
 
 
Declaração 
 Sintaxe: 
 tipo *identificador; /*o operador * indica q a 
 variável é um ponteiro*/ 
 
 Exemplo: 
 int *p; /*p é um ponteiro para um inteiro*/ 
 
Cuidado! 
 Um ponteiro deve sempre apontar para um 
local válido antes de ser utilizado 
 
Exemplo: 
int main () 
{ 
 int i=10, *pi; 
 *pi = 20; /*erro ! pi nao tem endereco valido*/ 
} 
 
Cuidado! 
 Um ponteiro deve sempre apontar para um 
local válido antes de ser utilizado 
 
Exemplo: 
int main () 
{ 
 int i=10, *pi; 
 pi = &i; /*pi contem o endereco de i*/ 
 *pi = 20; /*i passa a ser 20 */ 
} 
 
Atribuição 
 Exemplo: 
 int num; 
 int *p; 
 
 p = # 
 
 
 Atribuição pode ser: 
– direta: num = 100; 
– indireta: *p = 100; 
 
num 1024 
p 1034 
100 
Endereços Variáveis 
1024 
Operadores & e * 
 Operador &: operador de endereço, que 
quando aplicado sobre uma variável retorna 
o seu endereço 
 
 Operador *: operador indireto, que obtém o 
conteúdo do endereço apontado por uma 
variável 
 
Exemplos 
// ... 
int a = 10; 
int *b; 
 
printf(“Conteudo de a: %d\n", a); 
printf(“Endereco de a: %d\n", &a); 
b = &a; 
printf(“Endereco de b: %d\n", b); 
printf(“Conteudo de b: %d\n", *b); 
 
*b = 15; // atribuicao indireta 
printf(“Conteudo de a: %d\n", a); 
printf(“Conteudo de b: %d\n", *b); 
printf(“Conteudo de a: %d\n", *(&a)); 
// ... 
 
Exemplo 
Ponteiros 
 São variáveis tipadas: 
 (int *) ≠ (float *) ≠ (char *) 
 
 Exemplo: 
 int main() 
 { int *ip, x; 
 float *fp, z; 
 ip = &x; /* OK */ 
 fp = &z; /* OK */ 
 ip = &z; /* erro */ 
 fp = &x; /* erro */ 
 } 
 
Usando Ponteiros 
int main() 
{ 
 int x = 10; 
 int *pi; 
 pi = &x; /* *pi é igual a 10 */ 
 (*pi)++; /* *pi é igual a 11 */ 
 printf(“%d”, x); 
} 
 
 
OBS: Ao alterar *pi estamos alterando o conteúdo de x 
Usando Ponteiros 
int main() 
{ 
 int x = 10; 
 int *pi, *pj; 
 pi = &x; /* *pi é igual a 10 */ 
 pj = pi; /* *pj é igual a 10 */ 
 (*pi)++; /* (*pi, *pj, x) são iguais a 11 */ 
 (*pj)++; /* (*pi, *pj, x) são iguais a 12 */ 
 printf(“%d”, x); /* imprime 12 */ 
} 
 
Prática 
 Pratique a declaração e a utilização de 
ponteiros. 
– defina e inicialize uma variável inteira 
– defina um ponteiro para inteiro 
– modifique o valor da variável através do ponteiro 
– verifique os novos valores da variável usando 
printf 
 
Ponteiros e Vetores 
 Identificador do vetor é um ponteiro 
 Ex: int a[ ] = {1,2,3,4}; 
 a[0] e *a são iguais (acessam a mesma 
posição), 
 Logo: 
– a[i] é igual a: *(a + i) 
 
Ponteiros e Vetores 
 Exemplo: 
 char frase[ ] = {“Testando”}; 
 char *p; 
 p = frase; /* p contem o 
 endereco inicial de frase */ 
 
‘T’ 
‘e’ 
‘s’ 
‘t’ 
‘a’ 
‘n’ 
‘d’ 
‘o’ 
‘\0’ 
frase 
p 
OBS: Em char frase[ ], frase é uma 
constante que endereça o primeiro 
elemento do vetor. 
Referenciando elementos do vetor 
 Pode-se referenciar os elementos do array (vetor) 
através do seu nome e colchetes (acesso direto): 
 Ex: 
 //... 
 m[5] = 5.5; 
 if (m[5] == 5.5) 
 printf(“Exito”); 
 else 
 printf(“Falha”); 
 //... 
Referenciando elementos do vetor 
 Pode-se referenciar os elementos do array (vetor) 
através de ponteiros (acesso indireto): 
 Ex: 
 //... 
 float m[ ] = { 1.0, 3.0, 5.75, 2.345 }; 
 float *pf; 
 pf = &m[2]; 
 printf(“%f”, *pf); /* imprime 5.75 */ 
 //... 
Programa exemplo 
#include<stdio.h> 
#include<stdlib.h> 
main() 
{ int i; char *p; 
 char frase[ ] = {“Aprendendo a usar ponteiros!”}; 
 /*acessando os elementos do vetor diretamente pelo 
nome*/ 
 for(i=0; frase[i] != ‘\0’; i++) 
 putchar(frase[i]); 
 
 /*acessando os elementos do vetor indiretamente por 
meio de ponteiro*/ 
 for(p=frase; *p != ‘\0’; p++) 
 putchar(*p); 
 system(“PAUSE”); 
} 
 
Aritmética de ponteiros 
 É possível fazer operações aritméticas e 
relacionais entre ponteiros e inteiros 
 Soma: ao somar-se um inteiro n a um ponteiro, 
endereçamos n elementos a mais (n positivo) 
ou a menos (n negativo) 
 float m[ ] = { 1.0, 3.0, 5.75, 2.345 }; 
 float *pf; 
 pf = &m[2]; 
 
 
 
pf[2] equivale a *(pf+2) 
*(pf + n) acessa n elementos a frente 
*(pf - n) acessa n elementos atrás 
pf++ acessa o próximo elemento do array 
pf-- acessa o elemento anterior do array 
Operações válidas sobre ponteiros 
 E válido: 
– somar ou subtrair um inteiro a um ponteiro (pi ± int) 
– incrementar ou decrementar ponteiros (pi++, pi--) 
– subtrair ponteiros (produz um inteiro) (pf - pi) 
– comparar ponteiros ( >, >=, <, <=, == ) 
 Não é válido: 
– somar ponteiros (pi + pf) 
– multiplicar ou dividir ponteiros (pi*pf, pi/pf) 
– operar ponteiros com double ou float (pi ± 2.4) 
 
 
Exercício 1: Qual a saída do seguinte 
programa? 
//... 
main() 
{ int x = 4, y = 7; 
 int *px, *py; 
 
 /*imprimindo x e y diretamente*/ 
 printf(“Valor de x: %d Valor de y: %d”, x, y); 
 px = &x; // inicializando o ponteiro px 
 py = &y; // inicializando o ponteiro py 
 *px = *px + 10; 
 *py = *px + 10; 
 printf(“Valor de x: %d Valor de y: %d”, x, y); 
} 
 
Exercício 2 
 Escreva um programa que imprima um vetor 
de inteiros na ordem inversa, acessando os 
elementos por meio de um ponteiro. 
 
Solução 
 
	Ponteiros
	Ponteiros (ou apontadores)
	Ponteiros
	Declaração
	Cuidado!
	Cuidado!
	Atribuição
	Operadores & e *
	Exemplos
	Exemplo
	Ponteiros
	Usando Ponteiros
	Usando Ponteiros 
	Prática
	Ponteiros e Vetores
	Ponteiros e Vetores
	Referenciando elementos do vetor
	Referenciando elementos do vetor
	Programa exemplo
	Aritmética de ponteiros
	Operações válidas sobre ponteiros
	Exercício 1: Qual a saída do seguinte programa? 
	Exercício 2
	Solução