You are on page 1of 24

Estruturas de Dados 2


Aula 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

nonPointer1.Sintaxe de declaração <tipo> *<nome>. ! Exemplos: int *an_int_pointer. int *pointer1. . *pointer2. int *pointer1.

... p1 = p2. n. *p2. // atribui o endereço de n a p1 n = *p2. // declara dois ponteiros // e um int . // atribui o endereço apontado por // p2 a p1 p1 = &n. // atribui a n o valor (int) // apontado por p2 (de-referência) .Ponteiros e endereços de memória int *p1...

h> ! int *ptr = (int*)malloc (sizeof(int)).. // desaloca a memória . free(ptr). ..Alocação de memória dinâmica #include <stdlib. ! ou: ! int *ptr = (int*)malloc (sizeof(*ptr)).

int *intPtr. aponta para o 1º elemento do array • intPtr – variável.Ponteiros e arrays Variável do tipo array: constante que aponta para o primeiro elemento do array Exemplos: int intArray[6]. ! Ambos são ponteiros para int • intArray – constante. aponta para um inteiro em qualquer lugar da memória .

intPtr[0] = 12. ! intArray[3] = 13. int i.Ponteiros e arrays int intArray[6]. intPtr[3] = 13. . int *intPtr. ! intPtr = &i.

int i. // ERRADO. ! intPtr = &i. ! i intArray[3] = 13. mas ok (i=12) intPtr[3] = 13. // ok intPtr[0] = 12.Ponteiros e arrays int intArray[6]. não há um int // nesse endereço . // estranho. int *intPtr.

! arr[i] = 0. // atribui 0 ao elemento // i+1 do array ! *(arr + i) = 0. // idem .Aritmética com ponteiros Exemplo: int arr[10].

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]. ! Cálculo de ptr+i: ! addr(ptr+i) = addr(ptr) + [sizeof(int) * i] . *(ptr+i)). int *ptr = arr. printf(“%d”.

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] .

int a = 10. i. ! ! ! ! arr[0] = &a. i++) printf("**(ptr+%d): %d\n". arr[2] = &c. for (i=0. a int **ptr = arr. **(ptr+i)). i. i<3.arr int *arr[3]. arr[1] = &b. i<3. c = 1000. for (i=0. b = 100. b c . i++) printf("*arr[%d]: %d\n". *arr[i]).

int size ) { // code here } . int size ) { // code here } ! void foo( int * arr.Ponteiros como parâmetros em funções void foo( int arr[ 10 ].

! int arr2[ 10 ] .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[]. ! // Escreve 40 (tamanho do array arr2) cout << sizeof( arr2 ) . int size ) { // Escreve 4 (tamanho de um int*) cout << sizeof( arr ) . } .

! 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[1]: &arr[1][0] .Ponteiros e arrays de duas dimensões int arr[10][12]. arr[i]: &arr[i][0] **(arr) == arr[0][0] **(arr+1) == arr[1][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 .

Para Casa: Explicar.Atenção int arr[10][12]. . ! não é a mesma coisa que: ! int arr[120].

exceto por sizeof .Ponteiro para um array int (*ptr)[ 10 ]. // mesmo efeito da 1ª // declaração. // ponteiro para um // array de 10 // elementos ! int *ptr[10]. // array de 10 // ponteiros ! int *ptr.

! p1 = arr + 3 .Subtração int arr[ 10 ] . * p2 . // p1 == & arr[ 3 ] p2 = p1 .2 . // p2 == & arr[ 1 ] . int * p1.

int *p2 = arr + 5 . // Escreve 3 cout << ( p1 – p2 ) .p1 ) . // Escreve -3 .Subtração de ponteiros int arr[ 10 ] . ! cout << ( p2 . int *p1 = arr + 2 .

o programa pesquisa esse valor no primeiro vetor e escreve na tela o valor correspondente (mesma posição) encontrado no segundo vetor. Em seguida.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). Preencher ambos os vetores com dados. . ambos com o mesmo tamanho. o usuário digita um valor inteiro.