ALOCAÇÃO DINÂMICA

NA LINGUAGEM C
Prof. Dr. Juliano Varella de Carvalho
 ALOCAÇÃO DINÂMICA NA LINGUAGEM C
Um programa quando executado é carregado pelo Sistema Operacional para um espaço da memória.
Esse espaço é des�nado a armazenar o código do programa e também suas variáveis globais. Além desse
espaço, há um bloco de memória, conhecido como Pilha (ou Stack), des�nado a guardar as chamadas das
funções e as variáveis locais a estas funções. Quando o programa necessita de mais memória durante sua
execução (runtime), ou seja, quando precisa fazer alocação dinâmica, o espaço a ser reservado para o
programa será a área da memória conhecida como Heap.

Na linguagem C existem quatro funções u�lizadas para lidar com a alocação dinâmica de memória,
são elas: malloc(), calloc(), realloc() e free(). Essas funções podem ser encontradas na biblioteca <stdlib.h>. As
três primeiras permitem ao programa solicitar para o sistema operacional uma porção de Bytes do Heap.
Caso haja espaço suficiente no Heap, essas funções retornam o endereço onde inicia o bloco de memória
alocado. Caso não haja espaço, será retornado o valor NULL. A função free() é responsável por desalocar a
memória solicitada.

malloc()

Essa função serve para alocar uma quan�dade determinada de Bytes no Heap. Ela tem a seguinte
assinatura (protó�po):

void* malloc (unsigned int);

Portanto, a função recebe como parâmetro a quan�dade de Bytes necessária e devolve um ponteiro
(endereço) para o início do bloco alocado. Caso não exista espaço suficiente, a função retorna NULL.

Exemplo:

1 #include <stdio.h>
2 #include <stdlib.h>
3 #define TAM 3
4
5 int main () {
6 float *pf; int i;
7 pf = (float*) malloc(TAM * sizeof(float));
8 if (pf != NULL) {
9 for (i=0; i<TAM; i++) {
10 printf("Digite o valor %d: ", (i+1));
11 scanf("%f", (pf+i));
12 }
13 }
14 else {
15 printf("Problema de alocação de memória.");
16 exit(0);
17 }
18 printf("Valores armazenados\n");
19 for (i=0; i<TAM; i++)
20 printf("%.2f\t", *(pf+i));
21 free(pf);
22 return(0);
23 }

1
 No código descrito, a função malloc() é u�lizada na linha 7 para alocar um bloco de memória que
possa armazenar 3 floats. Como cada float ocupa 4 Bytes em memória, o bloco reservado é de 12 Bytes. Esse
bloco de 12 Bytes é alocado no Heap e o endereço inicial dele é retornado e armazenado no ponteiro pf.

As instruções con�das entre as linhas 9 e 12 são u�lizadas para colocar os três valores floats no bloco
reservado. Já as linhas 19 e 20 são u�lizadas para imprimir os valores lidos anteriormente. Note que na linha
20 o operador * é u�lizado na instrução *(pf+i) para “desreferenciar” o valor con�do no endereço (pf+i).

calloc()

A função calloc() tem o mesmo obje�vo da função malloc(). No entanto, ela possui uma assinatura
diferente, pois dois parâmetros são passados para dentro da função: o primeiro deles é a quan�dade de
valores a serem armazenados e o segundo parâmetro é o tamanho de cada um dos valores.

void* calloc (unsigned int, unsigned int);

Portanto, a linha 7 do código apresentado poderia alocar o bloco de memória necessário da seguinte
maneira:

pf = (float*) calloc(TAM, sizeof(float));

Uma outra su�l diferença entre as funções malloc() e calloc() é que a segunda inicia o bloco com
valores 0. O código a seguir u�liza a função calloc(), ao invés da função malloc(), na linha 7, a fim de efetuar
a alocação de um bloco de memória para armazenar três floats.

1 #include <stdio.h>
2 #include <stdlib.h>
3 #define TAM 3
4
5 int main () {
6 float *pf; int i;
7 pf = (float*) calloc(TAM, sizeof(float));
8 if (pf != NULL) {
9 for (i=0; i<TAM; i++) {
10 printf("Digite o valor %d: ", (i+1));
11 scanf("%f", (pf+i));
12 }
13 }
14 else {
15 printf("Problema de alocação de memória.");
16 exit(0);
17 }
18 printf("Valores armazenados\n");
19 for (i=0; i<TAM; i++)
20 printf("%.2f\t", *(pf+i));
21 free(pf);
22 return(0);
23 }

2
 realloc()

A função realloc() permite ao programa ajustar a alocação previamente realizada com as funções
malloc() ou calloc(). Ou seja, se o espaço previamente alocado tornar-se pequeno ou grande demais, é
possível reajustá-lo de acordo com as novas necessidades. A assinatura da função realloc() é realizada da
seguinte maneira:

void* realloc (void *, unsigned int);

A função recebe dois parâmetros de entrada. O primeiro deles é o ponteiro que deve ter sua alocação
alterada, e o segundo parâmetro informa o novo tamanho a ser alocado. O novo tamanho pode ser maior ou
menor do que o original. A função devolve como saída um ponteiro para o endereço inicial do novo bloco de
memória alocado. É importante salientar que o conteúdo já existente no bloco de memória anteriormente
alocado é copiado para o novo bloco, ou seja, os dados con�dos não são perdidos.

Observe a adaptação realizada no código a seguir. Na linha 18 foi u�lizada a seguinte instrução: pf =
(float*) realloc(pf, (TAM+2) * sizeof(float));
Essa instrução aloca espaço de memória para inserção de mais dois floats e o ponteiro pf, que antes apontava
para um bloco com 3 floats, passa a apontar para um bloco que permite o armazenamento de até 5 floats.

1 #include <stdio.h>
2 #include <stdlib.h>
3 #define TAM 3
4
5 int main () {
6 float *pf; int i;
7 pf = (float*) malloc(TAM * sizeof(float));
8 if (pf != NULL) {
9 for (i=0; i<TAM; i++) {
10 printf("Digite o valor %d: ", (i+1));
11 scanf("%f", (pf+i));
12 }
13 }
14 else {
15 printf("Problema de alocação de memória.");
16 exit(0);
17 }
18 pf = (float*) realloc(pf, (TAM+2) * sizeof(float));
19 if (pf != NULL) {
20 for (i=TAM; i<TAM+2; i++) {
21 printf("Digite o novo valor, %d: ", (i+1));
22 scanf("%f", (pf+i));
23 }
24 }
25 else {
26 printf("Problema de alocação de memória.");
27 exit(0);
28 }
29 printf("Valores armazenados\n");
30 for (i=0; i<TAM+2; i++)
31 printf("%.2f\t", *(pf+i));
32 free(pf);
33 return(0);
34 }
3
 free()

A função free() tem como propósito desalocar o bloco de memória alocado previamente com
malloc(), calloc() ou realloc(). Desta forma, o bloco de memória desalocado pode ser usado posteriormente
para outras necessidades. A assinatura dessa função é descrita da seguinte forma:

void free (void *);

Ou seja, a função free() não retorna nenhum valor e recebe como parâmetro o endereço (ponteiro)
inicial do bloco alocado com uma das funções: malloc(), calloc() ou realloc(). A linha 21 do código
apresentado ilustra o uso da função free().