Aula 17: Ponteiros e Alocação Dinâmica em C

Transcrição

1 Aula 17: Ponteiros e Alocação Dinâmica em C Fernanda Passos Universidade Federal Fluminense Programação de Computadores IV Fernanda Passos (UFF) Ponteiros e Alocação Dinâmica Programação de Computadores IV 1 / 32

2 Agenda 1 Revisão e Contexto 2 Definição de Ponteiros 3 Operações com Ponteiros 4 Alocação Dinâmica de Memória Fernanda Passos (UFF) Ponteiros e Alocação Dinâmica Programação de Computadores IV 2 / 32

4 Aula Anterior: Manipulação de arquivos: Vimos o conceito de arquivos e streams em C. Stream: fluxo de dados sequenciais. Arquivo: dispositivo associado ao stream. Como abrir e fechar: associar e desassociar um stream a um arquivo. Como escrever e ler de um stream de texto. Como identificar fim de arquivo. Fernanda Passos (UFF) Ponteiros e Alocação Dinâmica Programação de Computadores IV 4 / 32

5 Foco da Aula de Hoje Ponteiro: Definição em relação à memória do computador. Declaração e operadores relacionados a ponteiros. Operações com ponteiros. Alocação dinâmica: Funções de alocação dinâmica. Como usá-las. Objetivos: Entender o conceito de ponteiros em memória. Aprender como alocar dinamicamente memória usando funções pré-definidas em C. Fernanda Passos (UFF) Ponteiros e Alocação Dinâmica Programação de Computadores IV 5 / 32

7 Introdução: Memória A memória principal é o local onde o computador guarda a grande maioria das variáveis alocadas no programa. O processador precisa acessar a memória frequentemente para ter acesso a esses dados. O processador acessa a memória através de endereços. O endereço indica onde um valor está na memória. Organização de uma memória de tamanho T mem : Dados: Endereços: T mem -1 Fernanda Passos (UFF) Ponteiros e Alocação Dinâmica Programação de Computadores IV 7 / 32

8 Introdução: Memória (II) Considere o seguinte código: 1 int main(int argc, char * argv[]){ 2 char letra = b ; 3 return(0); 4 } Neste exemplo, uma variável do tipo char é alocada. Ela ocupará uma posição de memória e, portanto, terá um endereço (por ex.: 1024).... b T mem -1 A variável letra fica associada ao endereço de memória O comando &letra retorna Fernanda Passos (UFF) Ponteiros e Alocação Dinâmica Programação de Computadores IV 8 / 32

9 Ponteiro Definição de Ponteiro: É uma variável que contém um endereço de memória. Esse endereço é normalmente a posição de uma outra variável na memória. Dizemos que uma variável que contém um endereço aponta para outra variável. Dados: Endereços: T mem -1 Fernanda Passos (UFF) Ponteiros e Alocação Dinâmica Programação de Computadores IV 9 / 32

10 Declaração de um Ponteiro Um ponteiro precisa ser declarado como tal. Para isso, usamos um tipo base, um * e um nome para o ponteiro. Declaração de Ponteiro: tipo * nome; O tipo base é o tipo da variável para que o ponteiro aponta. Exemplo de uma declaração de ponteiro para o tipo char: 1 int main(int argc, char * argv[]){ 2 char letra = b ; 3 char * ponteiro_para_letra; 4 return(0); 5 } Fernanda Passos (UFF) Ponteiros e Alocação Dinâmica Programação de Computadores IV 10 / 32

12 Operadores de Ponteiros Existem dois: & e *. Ambos são operadores unários. Operador &: devolve o endereço na memória de seu operando. Exemplo: ptr letra = &letra; Lê-se ptr letra recebe o endereço de letra. Suponha que letra tem o valor b e está no endereço Então, ptr letra tem o valor ptr_letra letra Dados: Endereços: b T mem -1 Fernanda Passos (UFF) Ponteiros e Alocação Dinâmica Programação de Computadores IV 12 / 32

13 Operadores de Ponteiros (II) Operador *: devolve o valor da variável localizada no endereço indicado pelo seu operando. Geralmente usado sobre variável declarada como ponteiro. Exemplo: m = *ptr letra; Lê-se m recebe o valor do endereço de ptr letra. Se ptr letra guarda o endereço 1027 da variável letra, então m terá o valor de letra. Como no endereço há o valor b, logo, m terá o valor b. * ptr_letra letra Dados: Endereços: b T mem -1 Fernanda Passos (UFF) Ponteiros e Alocação Dinâmica Programação de Computadores IV 13 / 32

14 Operadores de Ponteiros: Exemplo 1 1 #include <stdio.h> 2 3 int main(int argc, char * argv[]){ 4 int * ptr; 5 int a = 100; 6 int b; 7 8 ptr = &a; 9 printf("valor de a: %d\n", a); 10 printf("endereco de a: %p\n", &a); 11 printf("valor de ptr_a: %p\n", ptr); 12 printf("endereco de ptr_a: %p\n", &ptr); 13 b = *ptr; 14 printf("valor de b: %d\n", b); 15 printf("endereco de b: %p\n", &b); 16 return(0); 17 } Exemplo de saída: Valor de a: 100 Endereco de a: 0x7fffa380f600 Valor de ptr_a: 0x7fffa380f600 Endereco de ptr_a: 0x7fffa380f608 Valor de b: 100 Endereco de b: 0x7fffa380f604 Fernanda Passos (UFF) Ponteiros e Alocação Dinâmica Programação de Computadores IV 14 / 32

15 Atribuição com Ponteiros Podemos fazer atribuições entre ponteiros. Um ponteiro pode ser atribuído a outro. 1 #include <stdio.h> 2 3 int main(int argc, char * argv[]){ 4 int x = 0; 5 int *p1, *p2; 6 7 p1 = &x; 8 p2 = p1; 9 10 printf("p1: %p e p2: %p\n", p1, p2); /* escreve o endereço de x, 11 não seu valor! */ 12 return(0); 13 } Fernanda Passos (UFF) Ponteiros e Alocação Dinâmica Programação de Computadores IV 15 / 32

16 Aritmética de Ponteiros Outro tipo de expressão é a aritmética de ponteiros. Apenas as operações de adição e subtração são permitidas. Agora, o tipo base do ponteiro faz toda a diferença! As operações de aritméticas são realizadas de acordo com o tamanho em bytes do tipo. Exemplo para um ponteiro p1 declarado como int: p1++; Neste exemplo, o valor de p1 é incrementado, mas no valor de sizeof(int) = 4 (bytes). Se o endereço inicial era 2000, ele passará a ser E não 2001! Fernanda Passos (UFF) Ponteiros e Alocação Dinâmica Programação de Computadores IV 16 / 32

17 Aritmética de Ponteiros: Exemplo 2 Acessar elementos de um vetor usando aritmética de ponteiros: 1 #include <stdio.h> 2 3 int main(int argc, char * argv[]){ 4 int i, vet[10]; 5 int *p; 6 7 for(i = 0; i<10; i++){ 8 vet[i] = i; 9 } 10 p = vet; // atribui o ponteito p ao vetor. 11 for(i = 0; i<10; i++){ 12 printf("%d ", *(p++)); 13 // Outra forma: 14 //printf("%d ", *(p + i)); 15 } 16 printf("\n"); return(0); 19 } Fernanda Passos (UFF) Ponteiros e Alocação Dinâmica Programação de Computadores IV 17 / 32

18 Inicialização de Ponteiros Algumas vezes, é necessário inicializar um ponteiro. Existe uma palavra reservada para isso: NULL. Um ponteiro, então, pode ser inicializado com o valor NULL. Exemplo de trecho: 1 int * p = NULL; 2 char * s; 3 4 s = NULL; Fernanda Passos (UFF) Ponteiros e Alocação Dinâmica Programação de Computadores IV 18 / 32

19 Ponteiro de Ponteiros (Indireção Múltipla) É possível criar ponteiro de ponteiros. Também chamado de indireção múltipla. É um ponteiro apontando para outro ponteiro que aponta para o valor final. Fernanda Passos (UFF) Ponteiros e Alocação Dinâmica Programação de Computadores IV 19 / 32

20 Ponteiro de Ponteiros: Declaração Neste caso, devemos declarar da seguinte maneira: tipo **ponteiro; O acesso do valor é feito por: **ponteiro; 1 #include <stdio.h> 2 3 int main(int argc, char * argv[]){ 4 int x, *p, **q; 5 6 x = 10; 7 p = &x; 8 q = &p; 9 10 printf("%d\n", **q); // Imprime o valor de x return(0); 13 } Fernanda Passos (UFF) Ponteiros e Alocação Dinâmica Programação de Computadores IV 20 / 32

22 Alocação Dinâmica de Memória Quando declaramos uma variável ou um vetor/matriz usando tipo nome, estamos declarando estaticamente. Uma declaração estática significa que uma região de memória é alocada durante a compilação. Deste modo, a região de memória alocada é inalterável. Uma consequência é que não se pode mudar seu tamanho depois de alocada. Em C, é possível alocar memória dinamicamente. i.e., em tempo de execução. Isto permite algumas facilidades, como alocar um tamanho de vetor/matriz de acordo com o seu real tamanho. Veremos, a seguir, como podemos fazer isso. Fernanda Passos (UFF) Ponteiros e Alocação Dinâmica Programação de Computadores IV 22 / 32

23 Funções de Alocação Dinâmica de Memória Em C, existem funções capazes de alocar memória dinamicamente. Estas funções estão disponíveis em stdlib.h. Portanto, stdlib.h deve ser incluída no código fonte do programa. São elas: Função Significado malloc() Aloca região de memória com tamanho especificado. calloc() Mesmo que malloc(), mas inicializa com 0. realloc() Altera o tamanho da região de memória previamente alocada. free() Libera região de memória previamente alocada. Veremos aqui apenas malloc() e free(). Fernanda Passos (UFF) Ponteiros e Alocação Dinâmica Programação de Computadores IV 23 / 32

24 Função malloc Assinatura da função malloc: void *malloc(size_t size); A função retorna um ponteiro para void. void é um tipo vazio. Serve para indicar que a função retorna ponteiro para qualquer tipo. Devemos usar casting ao alocar memória de um tipo específico. Repare que, agora, o uso de ponteiro é imprescindível. O único parâmetro da função malloc é o tamanho em bytes. É conveniente o uso do sizeof(tipo). Fernanda Passos (UFF) Ponteiros e Alocação Dinâmica Programação de Computadores IV 24 / 32

25 Função free Assinatura da função free: void free(void *ptr); A função não retorna nada (procedimento). O único parâmetro da função free é o ponteiro da memória a ser liberada. Comando para desalocar memória. Importante: um malloc sempre deve ter um free associado! Memória alocada consome espaço de armazenamento. Assim que terminar o uso, ela deve ser desalocada. Fernanda Passos (UFF) Ponteiros e Alocação Dinâmica Programação de Computadores IV 25 / 32

26 Função malloc e free: Exemplo 3 Alocar dinamicamente um inteiro: 1 #include <stdio.h> 2 #include <stdlib.h> 3 4 int main(int argc, char * argv[]){ 5 int * inteiro = NULL; 6 7 // Aloca um inteiro dinamicamente. 8 // Uso de cast de ponteiro para inteiro. 9 // O tamanho em bytes é sizeof(int). 10 inteiro = (int *) malloc(sizeof(int)); 11 // Atribui um valor ao inteiro alocado dinamicamente. 12 *inteiro = 5; 13 // Escreve seu valor. 14 printf("valor do inteiro: %d\n", *inteiro); free(inteiro); 17 return(0); 18 } Fernanda Passos (UFF) Ponteiros e Alocação Dinâmica Programação de Computadores IV 26 / 32

27 Alocação Dinâmica de Vetores/Matrizes Uma boa utilidade da alocação dinâmica é para alocar vetores e matrizes. Útil no caso de alocar vetores/matrizes de tamanho dinâmico. Por exemplo: Pedimos para que o usuário entre com o tamanho do vetor (ou vamos lê-lo); ao se conhecer esse tamanho (durante a execução do programa), seu programa alocará dinamicamente a memória necessária para armazená-lo. Desta forma, iremos alocar exatamente a quantidade de memória necessária. Não é mais necessário superestimar o tamanho do vetor como era feito na alocação estática. Fernanda Passos (UFF) Ponteiros e Alocação Dinâmica Programação de Computadores IV 27 / 32

28 Alocação Dinâmica de Vetores: Exemplo 4 Alocar dinamicamente um vetor de float de tamanho indicado pelo usuário: 1 #include <stdio.h> 2 #include <stdlib.h> 3 int main(int argc, char * argv[]){ 4 float * vet_float = NULL; 5 int tamanho_vet, i; 6 7 do{ 8 printf("digite o tamanho do vetor a ser alocado: "); 9 scanf("%d", &tamanho_vet); 10 } while(tamanho_vet <= 0 tamanho_vet > 1000); vet_float = (float *) malloc(tamanho_vet*sizeof(float)); 13 for(i=0; i<tamanho_vet; i++) 14 vet_float[i] = i / 2.0; printf("vetor de tamanho %d:\n", tamanho_vet); 17 for(i=0; i<tamanho_vet; i++) 18 printf("%.1f ", vet_float[i]); 19 printf("\n"); 20 free(vet_float); 21 return(0); 22 } Fernanda Passos (UFF) Ponteiros e Alocação Dinâmica Programação de Computadores IV 28 / 32

29 Alocação Dinâmica de Matrizes Para alocar matrizes, o procedimento é um pouco diferente. Uma matriz é uma espécie de vetor de vetores. Lembrando que usamos ponteiro para identificar um vetor. Sendo assim, para alocar matrizes dinamicamente, temos que: 1 alocar dinamicamente um vetor de ponteiros para o tipo da matriz, usando: tipo **ptr ptr; ptr ptr = (tipo **) malloc(m*sizeof(tipo *)); 2 para cada posição do vetor de ponteiros, alocar um novo vetor. for(i=0; i<m; i++) ptr ptr[i] = (tipo *) malloc(n*sizeof(tipo)); O tamanho do vetor de ponteiros corresponde ao número de linhas da matriz m. O tamanho de cada novo vetor corresponde ao número de colunas da matriz n. Fernanda Passos (UFF) Ponteiros e Alocação Dinâmica Programação de Computadores IV 29 / 32

30 Alocação Dinâmica de Matrizes (II) Para desalocar uma matriz o processo é inverso: 1 para cada posição do vetor de ponteiros, liberar o vetor usando: for(i=0; i<m; i++) free(ptr ptr[i]); 2 por último, liberar o vetor de ponteiros. free(ptr ptr); Fernanda Passos (UFF) Ponteiros e Alocação Dinâmica Programação de Computadores IV 30 / 32

31 Alocação Dinâmica de Matrizes: Exemplo 5 Alocar dinamicamente uma matriz m n, onde m e n são dados. 1 #include <stdio.h> 2 #include <stdlib.h> 3 int main(int argc, char * argv[]){ 4 int ** mat = NULL; 5 int m, n, i, j; 6 7 do{ 8 printf("digite as dimensoes da matriz: "); 9 scanf("%d %d", &m, &n); 10 } while(m <= 0 n<=0 m > 1000 n > 1000); // Alocacao de matriz: 13 mat = (int **) malloc(m*sizeof(int *)); 14 for(i=0; i<m; i++) 15 mat[i] = (int *) malloc(n*sizeof(int)); // continua... Fernanda Passos (UFF) Ponteiros e Alocação Dinâmica Programação de Computadores IV 31 / 32

32 Alocação Dinâmica de Matrizes: Exemplo 5 (cont.) 18 mat = (int **) malloc(m*sizeof(int *)); 19 for(i=0; i<m; i++) 20 mat[i] = (int *) malloc(n*sizeof(int)); for(i=0; i<m; i++) 23 for(j=0; j<n; j++) 24 mat[i][j] = i*m + j; 25 for(i=0; i<m; i++){ 26 for(j=0; j<n; j++) 27 printf("%4d ", mat[i][j]); 28 printf("\n"); 29 } // Libera a matriz: 32 for(i=0; i<m; i++) free(mat[i]); 33 free(mat); return(0); 36 } Fernanda Passos (UFF) Ponteiros e Alocação Dinâmica Programação de Computadores IV 32 / 32