Programação de Computadores - Aritmética de Ponteiros

Prévia do material em texto

Universidade Estadual do Centro Oeste - UNICENTRO 
Departamento de Ciência da Computação - DECOMP 
Programação de Computadores II 
Aritmética de Ponteiros 
Professora: Inali Wisniewski Soares 
Ponteiros 
 Um ponteiro é uma variável que armazena um endereço 
de memória de um objeto. 
 Operadores especiais para ponteiros: 
 O operador * (redireção ou indireção) – indica que a variável é 
um ponteiro. 
 O operador * quando aplicado sobre um ponteiro retorna o 
dado apontado. 
 O operador & (endereço) – quando aplicado sobre uma 
variável retorna o seu endereço. 
 
2 
Utilizando ponteiros (1) 
int main (void){ 
 int x = 10; 
 int *pi; 
 
 pi = &x; /* *pi == 10 */ 
 (*pi)++; /* *pi == 11 */ 
 printf("\n%d\n", x); 
 return 0; 
} 
 
 Ao alterar *pi altera-se o conteúdo de x 
3 
Utilizando ponteiros (2) 
int main (void){ 
 int x = 10; 
 int *pi, *pj; 
 
 pi = &x; /* *pi == 10 */ 
 pj = pi; /* *pj == 10 */ 
 (*pi)++; /* *pi == 11 */ 
 (*pj)++; /* *pj == 12 */ 
 printf("\n%d\n", x); 
 return 0; 
} 
 
 
4 
Aritmética de Ponteiros (1) 
 É possível realizar operações aritméticas e relacionais 
entre ponteiros e números inteiros. 
 
 Soma: ao somar um inteiro n a um ponteiro, 
endereçamos n elementos a mais (n positivo) ou a menos 
(n negativo). 
 pf[2] equivale a *(pf+2) 
 *(pf + n) /*endereça n elementos a frente */ 
 *(pf - n) /*endereça n elementos a atrás */ 
 pf++ /* endereça próximo elemento array */ 
 pf-- /* endereça elemento anterior array */ 
 
 5 
Exemplo (1) 
 1 #include <stdio.h> 
 2 int main (void) { 
 3 int *px, *py; 
 4 int a[5] = {7, 9, 1, 10, 15}; 
 5 px = &a[0]; 
 6 py = &a[4]; 
 7 printf("\npx = %d py = %d", px, py); 
 8 printf("\npy – px = %d", py – px); 
 9 printf("\n%d %d ", *px, *py); 
10 return 0; 
11 } 
 
 A diferença py – px é = 4 (linha 8), pois a[4] é o 
quinto elemento do vetor a. Assim, a[4] é armazenado em 
um endereço 16 bytes além do endereço de a[0], pois uma 
variável do tipo int ocupa 4 bytes de memória. Desse 
modo a diferença entre py e px é igual 4, pois 16/4=4. 
 
6 
Exemplo (2) 
#include <stdio.h> 
#define MAX 5 
 
int main(void){ 
 int valores[MAX] = {1, 2, 3, 4, 5}; 
 int contador; 
 int *iptr; 
 
 iptr = valores; /* equivale a iptr = &valores[0] */ 
 for (contador = 0; contador < MAX; contador++){ 
 printf("%d\n", *iptr); 
 iptr++; /* valor de iptr é incrementado para 
exibir os cinco elementos do vetor */ 
 } 
 return 0; 
} 
7 
Exemplo (3) 
#include <stdio.h> 
 
int tam_str(char st[]); 
 
int main(void){ 
 printf("%d", tam_str("Biblia do Programador C")); 
 return 0; 
} 
/* retorna o tamanho da string st usando ponteiro */ 
int tam_str(char st[]){ 
 int i; 
 for(i=0; *(st + i) != '\0'; i++) 
 ; 
 return i; 
} 
8 
Exemplo (4) 
#include <stdio.h> 
int main(void){ 
 int arint[] = {1,2,3,4,5,6,7}; 
 int *pi; 
 
 pi = arint; 
 printf(" %d ", *pi); 
 pi += 2; 
 printf(" %d ", *pi); 
 pi += 2; 
 printf(" %d ", *pi); 
 pi += 2; 
 printf(" %d ", *pi); 
 return 0; 
} 
 9 
Operações válidas sobre ponteiros 
 É válido: 
 Somar ou subtrair um inteiro a um ponteiro 
 Incrementar ou decrementar ponteiros (pi++, pi--) 
 Subtrair ponteiros (produz um inteiro) (pf – pi) 
 Comparar ponteiros ( >, >=, <,<=, ==), desde que os ponteiros apontem 
para elementos do mesmo tipo. 
 
 Não é válido 
 Somar ponteiros (pi + pf) 
 Multiplicar ou dividir ponteiros (pi * p2, pi/p2) 
 Operar ponteiros com double ou float (pi + 2.0 ou pi – 2.0) 
 
10 
Operador sizeof – retorna o núm. de bytes de uma 
variável 
#include <stdio.h> 
int main(void) { 
 char letra[5] = {'a','e','i','o','u'}; 
 int contador, nr[5] = {30,12,67,13,41}; 
 char *ptr_letra; 
 int *ptr_nr; 
 ptr_letra = letra; 
 ptr_nr = nr; 
 printf("Visualizando como funciona a aritmética de ponteiros\n"); 
 printf("\nmatriz letra = a, e, i, o, u\n"); 
 printf("matriz nr = 30,12,67,13,41\n"); 
 printf("\nVerificando o tamanho dos tipos de dados\n"); 
 printf("tamanho do tipo de dado char = %d\n",sizeof(char)); 
 printf("tamanho do tipo de dado int = %d\n",sizeof(int)); 
 printf("\nPonteiro para letra aponta para %c no endereco %x\n",*ptr_letra,ptr_letra); 
 printf("Ponteiro para nr aponta para %d no endereco %x\n",*ptr_nr,ptr_nr); 
 printf("\nIncrementando os ponteiros\n"); printf("ptr_letra + 3, ptr_nr + 2\n"); 
 ptr_letra += 3; ptr_nr += 2; 
 printf("\nPonteiro para letra agora aponta para %c no endereco 
%x\n",*ptr_letra,ptr_letra); 
 printf("Ponteiro para nr agora aponta para %d no endereco %x\n",*ptr_nr,ptr_nr); 
 return(0); 
 } 
 
11