Alocaçao Dinamica de Memoria

Prévia do material em texto

Programação Aplicada
Alocação dinâmica de memória
Agostinho Brito
Departamento de Engenharia da Computação e Automação
Universidade Federal do Rio Grande do Norte
22 de fevereiro de 2006
Sumário
O que é alocação dinâmica de memória.
Alocando e desalocando memória.
Alocando matrizes.
O que é alocação dinâmica de memória
A alocação dinâmica permite ao programador alocar memória para
variáveis quando o programa está sendo executado.
É possível criar um vetor ou matriz cujo tamanho somente será definido
em tempo de execução.
O padrão C ANSI define apenas 4 funções para o sistema de alocação
dinâmica, disponíveis na biblioteca stdlib.h:
malloc(): aloca memória
calloc(): aloca memória e inicia com zeros
realloc(): redimensiona o tamanho da memória alocada.
free(): libera memória alocada
Alocando memória com malloc()
A função malloc() possui o seguinte protótipo:
void *malloc (unsigned int num);
A função malloc() lê a quantidade num bytes a alocar, reserva a
memória correspondente e retorna o endereço do primeiro byte alocado.
O tipo *void permite a alocação de qualquer tipo de ponteiro.
Se não houver memória disponível para alocar, a função retorna um
ponteiro nulo (NULL).
Exemplo de alocação para 30 valores do tipo double:
double * pd;
pd = (double *) malloc(30 * sizeof(double));
A operação realizada com o (double *) é chamada de casting. Ela
converte o tipo retornado pela função malloc() de ponteiro para void
em ponteiro para double.
Note que pdt é declarada com ponteiro para um simples double e não
para um bloco de 30 doubles.
Liberando memória com free()
A função free() recebe como argumento um endereço previamente
alocado com malloc() e libera a memória alocada.
Para cada alocação, realizar uma liberação correspondente, de modo que
a memória possa ser reutilizada.
Protótipo da função:
void free(void *ptr);
Exemplo de uso:
free(pd);
Redimensionando o bloco de memória com
realloc()
realloc() redimensiona a memória de forma não destrutiva.
double * pd;
pd = (double *) malloc(30 * sizeof(double));
pd = realloc(pd, 40 * sizeof(double));
Exemplo - alocação de um vetor de doubles
#include <stdio.h>
#include <stdlib.h> /* para malloc() e free() */
int main(void){
double * pd;
int max, numero, i = 0;
puts("Qual tamanho do vetor de doubles?");
scanf("%d", &max);
pd = (double *) malloc(max * sizeof (double));
if (pd == NULL){
puts("Falhou alocacao. Finalizando.");
exit(EXIT_FAILURE);
}
puts("Digite os valores do vetor (q para desistir):");
while (i < max && scanf("%lf", &pd[i]) == 1)
++i;
printf("Aqui estão os %d elementos:\n", numero = i);
for (i = 0; i < numero; i++){
printf("%7.2f ", pd[i]);
if (i % 7 == 6)
putchar(’\n’);
}
if (i % 7 != 0)
putchar(’\n’);
puts("Terminou.");
free(pd);
return 0;
}
Por que utilizar free()
O que acontece com o seguinte trecho de código?
...
int main()
{
double x[2000];
int i;
...for (i = 0; i < 1000; i++)
aloca(x, 2000);
...}
void aloca(double ar[], int n)
{
double * temp = (double *) malloc( n * sizeof(double));
... /* free(temp); // forgot to use free() */
}
Alocando memória com calloc()
Alocando 100 espaços de memória do tamanho long (4 bytes).
long * newmem;
newmem = (long *)calloc(100, sizeof (long));
Inicia todos os elementos com bits 0.
Memória pode ser liberada com free().
Alocando matrizes
A alocação dinâmica de arrays multidimensionais é feito utilizando as
funções de manipulação de memória apresentadas.
Arrays multidimensionais são criados utilizando ponteiros para ponteiros.
int* int int int int
int**
int int int int
int int int int
int int int intint*
int*
int*
x[0]
x
x[0] = (int*) malloc(4 * sizeof(int));
x = (int**) malloc(4 * sizeof(int*));
int **x;
	Sumário
	O que é alocação dinâmica de memória
	Alocando e desalocando memória
	Alocando matrizes