Alocação Dinâmica de Memória. Programação II

Transcrição

1 Alocação Dinâmica de Memória Programação II

2 Alocação dinâmica Uso da memória Uso de variáveis globais (e estáticas): Espaço reservado para uma variável global existe enquanto o programa estiver sendo executado. Uso de variáveis locais: Espaço existe apenas enquanto a função que declarou a variável está sendo executada. Liberado para outros usos quando a execução da função termina. Variáveis globais ou locais podem ser simples ou vetores: Para vetor, é necessário informar o número máximo de elementos pois o compilador precisa calcular o espaço a ser reservado.

3 Alocação dinâmica Uso da memória Alocação dinâmica: Espaço de memória é requisitado em tempo de execução. Espaço permanece reservado até que seja explicitamente liberado: Depois de liberado, espaço estará disponibilizado para outros usos e não pode mais ser acessado; Espaço alocado e não liberado explicitamente, será automaticamente liberado ao final da execução.

4 Alocação dinâmica Uso da memória Memória estática: Código do programa; Variáveis globais; Variáveis estáticas. Memória dinâmica: Variáveis alocadas dinamicamente; Memória livre; Variáveis locais.

5 Alocação dinâmica Uso da memória Alocação dinâmica de memória: Usa a memória livre; Se o espaço de memória livre for menor que o espaço requisitado, a alocação não é feita e o programa pode prever tratamento de erro. Pilha de execução: Utilizada para alocar memória quando ocorre chamada de função: Sistema reserva o espaço para as variáveis locais da função; Quando a função termina, espaço é liberado (desempilhado). Se a pilha tentar crescer mais do que o espaço disponível existente, programa é abortado com erro.

6 Alocação dinâmica e Ponteiros É possível alocar dinamicamente uma quantidade de memória contígua e associá-la com um ponteiro. Desta forma podemos criar programas sem saber a quantidade de dados a ser armazenada. Exemplo: int M[100][100]; Mas, se o usuário precisar trabalhar com matrizes maiores? Na biblioteca stdlib.h existem duas funções para fazer alocação de memória.

7 Alocação dinâmica e Ponteiros calloc: são passados como parâmetro o número de blocos de memória a serem alocados e o tamanho em bytes de cada bloco. Exemplo: alocar 100 números inteiros. int *p; p = calloc (100, sizeof(int)); Atenção! A função calloc() zera todos os bits da memória alocada! p = (int *) calloc (100 * sizeof(int)); malloc: é passado um único argumento, que é o número de bytes a serem alocados. Exemplo: alocar 100 números inteiros. int *p; p = malloc (100 * sizeof(int)); Atenção! A função malloc() NÃO zera os bits da memória alocada, por isso é mais rápida! p = (int *) malloc (100 * sizeof(int));

8 Alocação dinâmica e Ponteiros free: recebe como parâmetro um ponteiro, e libera a memória previamente alocada e apontada pelo ponteiro.. Exemplo: alocar 100 números inteiros. int *p; p = malloc (100 * sizeof(int));... free(p); p = (int *) malloc (100 * sizeof(int)); Uso correto da alocação dinâmica: toda memória alocada durante a execução de um programa deve ser liberada ( com a função free() ) quando não for mais utilizada. Exemplo: alocar 100 números inteiros. int *p; p = malloc (100 * sizeof(int)); p = (int *) malloc (100 * sizeof(int));

9 Alocação dinâmica e Ponteiros: Exemplo

10 Alocação dinâmica e Ponteiros: Cuidado!!! Você pode fazer ponteiros distintos apontarem para uma mesma região de memória. Exemplo: Tome cuidado para não utilizar um ponteiro se a região de memória apontada foi desalocada! double *v1, *v2; v1 = (double *) malloc(100 * sizeof(double)); v2 = v1; free(v1); for(i = 0; i < n; i++) v2[i] = i * i; O código acima está errado e pode causar erros durante a execução pois v2 está acessando posições de memória que não pertencem mais ao programa!

11 Alocação dinâmica de matrizes (ponteiro para ponteiros) Uma variável ponteiro está alocada na memória do computador como qualquer outra variável. Portanto podemos criar um ponteiro que contém o endereço de memória de um outro ponteiro. Para criar um ponteiro para ponteiro: tipo **nomeponteiro;

12 Alocação dinâmica de matrizes (ponteiro para ponteiros) O programa imprime o valor 5 três vezes, mostrando as três formas de acesso à variável a: a, *b, **c. c = &b; b = &a;

13 Alocação dinâmica de matrizes (ponteiro para ponteiros) Aprendemos que um ponteiro pode ser usado para referenciar um vetor alocado dinamicamente. Exemplo: int *p; p = (int *) calloc(5, sizeof(int));

14 Alocação dinâmica de matrizes (ponteiro para ponteiros) A mesma coisa acontece com um ponteiro para ponteiro, mas que neste caso o vetor alocado é de ponteiros. Exemplo: int **p; p = (int **) calloc(5, sizeof(int *)); Note que cada posição do vetor é do tipo int *, ou seja, um ponteiro para inteiro!

15 Alocação dinâmica de matrizes (ponteiro para ponteiros) Como cada posição do vetor é um ponteiro para inteiro, podemos associar cada posição dinamicamente com um vetor de inteiros! Exemplo: int **p, i; p = (int **) calloc(5, sizeof(int *)); for(i = 0; i < 5; i++){ } p[i] = (int *) calloc(3, sizeof(int));

16 Alocação dinâmica de matrizes (ponteiro para ponteiros) Esta é a forma de se criar matrizes dinamicamente: Crie um ponteiro para ponteiro; Associe um vetor de ponteiros dinamicamente com este ponteiro de ponteiro. O tamanho deste vetor é o número de linhas da matriz; Cada posição do vetor será associado com um outro vetor do tipo a ser armazenado. Cada um destes vetores é uma linha da matriz (portanto possui tamanho igual ao número de colunas); Ao final deve-se liberar toda a memória alocada!

17 Alocação dinâmica de matrizes (ponteiro para ponteiros)

18 Exercício Crie um programa que multiplica duas matrizes quadradas do tipo inteiro lidas do teclado. Seu programa deve ler a dimensão N da matriz e em seguida alocar dinamicamente duas matrizes N x N. Depois ler os dados das duas matrizes, o programa deve imprimir a matriz resultante da multiplicação entre elas.

19