ALOCAÇÃO DINÂMICA

1 - Alocação Dinâmica

A alocação dinâmica permite ao programador alocar memória para variáveis quando o programa está sendo
executado. Assim, poderemos definir, por exemplo, um vetor ou uma matriz cujo tamanho descobriremos 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

calloc

realloc

free

No entanto, existem diversas outras funções que são amplamente utilizadas, mas dependentes do ambiente e
compilador. Aqui serão abordadas somente estas funções padronizadas.

I – função malloc()

A função malloc() serve para alocar memória e tem o seguinte protótipo:

void *malloc (unsigned int num);

A funçao toma o número de bytes que queremos alocar (num), aloca na memória e retorna um ponteiro void * para o
primeiro byte alocado. O ponteiro void * pode ser atribuído a qualquer tipo de ponteiro. Se não houver memória
suficiente para alocar a memória requisitada a função malloc() retorna um ponteiro nulo. Veja um exemplo de
alocação dinâmica com malloc():

#include <stdio.h>
#include <stdlib.h> /* Para usar malloc() */
main (void)
{
int *p;
int a;
int i;
... /* Determina o valor de a em algum lugar */
p=(int *)malloc(a*sizeof(int)); /* Aloca a números inteiros
p pode agora ser tratado
como um vetor com a posicoes */
if (!p)
{
printf ("** Erro: Memoria Insuficiente **");
exit;
}

for (i=0; i<a ; i++) /* p pode ser tratado como

um vetor com a posicoes */
p[i] = i*i;
...
return 0;
}

No exemplo acima, é alocada memória suficiente para se armazenar a números inteiros. O operador sizeof() retorna o
número de bytes de um inteiro. Ele é util para se saber o tamanho de tipos. O ponteiro void* que malloc() retorna é
convertido para um int* pelo cast e é atribuído a p. A declaração seguinte testa se a operação foi bem sucedida. Se
não tiver sido, p terá um valor nulo, o que fará com que !p retorne verdadeiro. Se a operação tiver sido bem sucedida,
podemos usar o vetor de inteiros alocados normalmente, por exemplo, indexando-o de p[0] a p[(a-1)].

Página 1 de 3
II – Função calloc()

A função calloc() também serve para alocar memória, mas possui um protótipo um pouco diferente:

void *calloc (unsigned int num, unsigned int size);

A funçao aloca uma quantidade de memória igual a num * size, isto é, aloca memória suficiente para um vetor de
num objetos de tamanho size. Retorna um ponteiro void * para o primeiro byte alocado. O ponteiro void * pode ser
atribuído a qualquer tipo de ponteiro. Se não houver memória suficiente para alocar a memória requisitada a função
calloc() retorna um ponteiro nulo. Veja um exemplo de alocação dinâmica com calloc():

#include <stdio.h>
#include <stdlib.h> /* Para usar calloc() */
main (void)
{
int *p;
int x;
int i;
... /* Determina o valor de a em algum lugar */
p=(int *)calloc(a,sizeof(int)); /* Aloca a números inteiros
p pode agora ser tratado como um vetor com a posicoes */
if (!p)
{
printf ("** Erro: Memoria Insuficiente **");
exit;
}
for (i=0; i<a ; i++) /* p pode ser tratado como um
vetor com a posicoes */
p[i] = i*i;
...
return 0;
}

No exemplo acima, é alocada memória suficiente para se colocar a números inteiros. O operador sizeof() retorna o
número de bytes de um inteiro. Ele é util para se saber o tamanho de tipos. O ponteiro void * que calloc() retorna é
convertido para um int * pelo cast e é atribuído a p. A declaração seguinte testa se a operação foi bem sucedida. Se
não tiver sido, p terá um valor nulo, o que fará com que !p retorne verdadeiro. Se a operação tiver sido bem sucedida,
podemos usar o vetor de inteiros alocados normalmente, por exemplo, indexando-o de p[0] a p[(a-1)].

III – Função realloc()

A função realloc() serve para realocar memória e tem o seguinte protótipo:

void *realloc (void *ptr, unsigned int num);

A funçao modifica o tamanho da memória previamente alocada apontada por *ptr para aquele especificado por num.
O valor de num pode ser maior ou menor que o original. Um ponteiro para o bloco é devolvido porque realloc() pode
precisar mover o bloco para aumentar seu tamanho. Se isso ocorrer, o conteúdo do bloco antigo é copiado no novo
bloco, e nenhuma informação é perdida. Se ptr for nulo, aloca size bytes e devolve um ponteiro; se size é zero, a
memória apontada por ptr é liberada. Se não houver memória suficiente para a alocação, um ponteiro nulo é
devolvido e o bloco original é deixado inalterado.

#include <stdio.h>
#include <stdlib.h> /* Para usar malloc() e realloc*/
main (void)
{
int *p;
int x;
int i;
... /* Determina o valor de a em algum lugar */
a = 30;

Página 2 de 3
 p=(int *)malloc(a*sizeof(int)); /* Aloca a números inteiros
p pode agora ser tratado
como um vetor com a posicoes */
if (!p)
{
printf ("** Erro: Memoria Insuficiente **");
exit;
}
for (i=0; i<a ; i++) /* p pode ser tratado como
um vetor com a posicoes */
p[i] = i*i;

/* O tamanho de p deve ser modificado, por algum motivo ... */

a = 100;
p = (int *) realloc (p, a*sizeof(int));
/* p pode ser tratado como um vetor com a posicoes */
for (i=0; i<a ; i++)
p[i] = a*i*(i-6);
...
return 0;
}

IV – Função free()

Quando alocamos memória dinamicamente é necessário que nós a liberemos quando ela não for mais necessária. Para
isto existe a função free() cujo protótipo é:

void free (void *p);

Basta então passar para free() o ponteiro que aponta para o início da memória alocada. Mas você pode se perguntar:
como é que o programa vai saber quantos bytes devem ser liberados? Ele sabe pois quando você alocou a memória,
ele guardou o número de bytes alocados numa "tabela de alocação" interna. Vamos reescrever o exemplo usado para a
função malloc() usando o free() também agora:

#include <stdio.h>
#include <stdlib.h> /* Para usar malloc e free */
main (void)
{
int *p;
int a;
...
p=(int *)malloc(a*sizeof(int));
if (!p)
{
printf ("** Erro: Memoria Insuficiente **");
exit;
}
...
free(p);
...
return 0;
}

Página 3 de 3