aula01 c aritimeticadeponteiros
DESCRIPTION
A presentation on pointers in c programming languageTRANSCRIPT
Estruturas de Dados 2Aula 01 – Revisão de Linguagem C: Aritmética com Ponteiros
!Prof. Fábio M. Costa Curso: Bacharelado em Ciência da Computação Instituto de Informática Universidade Federal de Goiás !2º Semestre / 2014
Ponteiros
Sintaxe de declaração Ponteiros e endereços de memória Ponteiros e arrays Aritmética com ponteiros !Justificativa: a implementação da maior parte das
estruturas de dados estudadas requer o uso de ponteiros
Sintaxe de declaração
<tipo> *<nome>; !Exemplos:
int *an_int_pointer; int *pointer1, nonPointer1; int *pointer1, *pointer2;
Ponteiros e endereços de memória
int *p1, *p2, n; // declara dois ponteiros
// e um int
...
...
p1 = p2; // atribui o endereço apontado por
// p2 a p1
p1 = &n; // atribui o endereço de n a p1
n = *p2; // atribui a n o valor (int)
// apontado por p2 (de-referência)
Alocação de memória dinâmica
#include <stdlib.h>
!int *ptr = (int*)malloc (sizeof(int)); !ou: !int *ptr = (int*)malloc (sizeof(*ptr)); ... free(ptr); // desaloca a memória
Ponteiros e arrays
Variável do tipo array: constante que aponta para o primeiro elemento do array
Exemplos: int intArray[6]; int *intPtr;
!Ambos são ponteiros para int • intArray – constante, aponta para o 1º elemento do array • intPtr – variável, aponta para um inteiro em qualquer lugar da
memória
Ponteiros e arrays
int intArray[6];
int *intPtr;
int i;
!intPtr = &i;
!intArray[3] = 13;
intPtr[0] = 12;
intPtr[3] = 13;
Ponteiros e arrays
int intArray[6];
int *intPtr;
int i;
!intPtr = &i;
!intArray[3] = 13; // ok
intPtr[0] = 12; // estranho, mas ok (i=12)
intPtr[3] = 13; // ERRADO; não há um int
// nesse endereço
i
Aritmética com ponteiros
Exemplo: int arr[10]; !arr[i] = 0; // atribui 0 ao elemento // i+1 do array !*(arr + i) = 0; // idem
Aritmética com ponteiros
O tamanho do incremento depende do tipo do ponteiro Ex.: int arr[2];
Aritmética com ponteiros
Exemplo 2: short arr[5];
Aritmética com ponteiros
Cálculo de endereços: int arr[10]; int *ptr = arr; printf(“%d”, *(ptr+i));
!Cálculo de ptr+i: !
addr(ptr+i) = addr(ptr) + [sizeof(int) * i]
Aritmética com ponteiros
Cálculo de endereços: int *arr[10]; // array de ponteiros int **ptr = arr; // ponteiro para // ponteiro
!Cálculo de ptr+i: !
addr(ptr+i) = addr(ptr) + [sizeof(int*) * i]
arr
int *arr[3]; int a = 10, b = 100, c = 1000; ! arr[0] = &a; arr[1] = &b; arr[2] = &c; ! for (i=0; i<3; i++) printf("*arr[%d]: %d\n", i, *arr[i]); ! int **ptr = arr; ! for (i=0; i<3; i++) printf("**(ptr+%d): %d\n", i, **(ptr+i));
a
b
c
Ponteiros como parâmetros em funções
void foo( int arr[ 10 ], int size ) { // code here }
!void foo( int * arr, int size ) { // code here }
Ponteiros como parâmetros em funções
Por que passar o comprimento do array? // O compilador traduz o tipo de arr para int *
void foo ( int arr[], int size ) {
// Escreve 4 (tamanho de um int*)
cout << sizeof( arr ) ;
! int arr2[ 10 ] ;
! // Escreve 40 (tamanho do array arr2)
cout << sizeof( arr2 ) ;
}
Ponteiros e arrays de duas dimensões
int arr[10][12]; !
não é a mesma coisa que !int *arr[10];
Veja a seguir…
Ponteiros e arrays de duas dimensões
int arr[10][12]; !
arr[0]: &arr[0][0] **(arr) == arr[0][0] arr[1]: &arr[1][0] **(arr+1) == arr[1][0] ... arr[i]: &arr[i][0] **(arr+i) == arr[i][0]
Ponteiros e arrays de duas dimensões
int *arr[10]; // tipo: int **
!arr + i: &arr[0] + sizeof(int*) * i
Atenção
int arr[10][12];
!não é a mesma coisa que: !int arr[120];
Para Casa: Explicar.
Ponteiro para um array
int (*ptr)[ 10 ]; // ponteiro para um // array de 10 // elementos !int *ptr[10]; // array de 10 // ponteiros
!int *ptr; // mesmo efeito da 1ª // declaração, exceto por sizeof
Subtração
int arr[ 10 ] ; int * p1, * p2 ; !p1 = arr + 3 ; // p1 == & arr[ 3 ] p2 = p1 - 2 ; // p2 == & arr[ 1 ]
Subtração de ponteiros
int arr[ 10 ] ; int *p1 = arr + 2 ; int *p2 = arr + 5 ; !cout << ( p2 - p1 ) ; // Escreve 3 cout << ( p1 – p2 ) ; // Escreve -3
Exercício de programação
Utilizando somente notação de ponteiros, alocar um vetor de inteiros e um vetor de números de ponto flutuante de precisão dupla (double), ambos com o mesmo tamanho. Preencher ambos os vetores com dados.
Em seguida, o usuário digita um valor inteiro; o programa pesquisa esse valor no primeiro vetor e escreve na tela o valor correspondente (mesma posição) encontrado no segundo vetor.