Alocação Dinâmica

Quando precisamos guardar alguma informação que será utilizada pelo programa, utilizamos variáveis. Passamos o tipo da variável e o tamanho que aquela variável vai receber de informação, isso pode ser um problema, por que muitas vezes não sabemos o tamanho da informação que será gravada nela durante a criação do programa. Outro ponto é que o tamanho de um determinado tipo pode mudar dependendo do computador, ou seja, um inteiro pode ter 4 bytes na minha máquina mas ter um tamanho diferente na sua.

Para resolver esse problema, usamos a alocação dinâmica. O C possui 4 funções disponíveis para alocação dinâmica de memória e estão disponíveis na biblioteca stdlib.h. São elas:

• malloc

• calloc

• realloc

• free

Vamos entender cada uma delas.

Função malloc()

A função malloc serve para alocar memória durante a execução do programa. A função recebe como parâmetro a quantidade de bytes para ser alocado e retorna um ponteiro para a primeira posição do array. Caso não tenha espaço suficiente ou caso ocorra algum erro, ela retorna NULL.

Protótipo da função:

void* malloc(unsigned int num);

Exemplos:

//cria um array de 200 bytes
int *v = malloc(200);

//cria um array com o tamanho de 50 inteiros
int *v = malloc(50 * sizeof(int));

//como a função retorna um ponteiro genérico
//é possível fazer uma conversão explicita
int *v = (int*) malloc(50 * sizeof(int));

Como falado anteriormente, caso a função tenha algum problema, ela retorna como resultado NULL, então é sempre interessante realizar uma validação para evitar erros.

int *p;
p = (int*) malloc(50 * sizeof(int));
if(p == NULL){
	printf("Erro na alocação de memória!\n");
	exit(1);
}

Função calloc()

Assim como o malloc a função calloc serve para alocar memória durante a execução do programa. Ela recebe como parâmetro o número de elementos do array a ser alocado e o tamanho de cada elemento e retorna um ponteiro para a primeira posição do array. Caso não tenha espaço suficiente ou caso ocorra algum erro, ela retorna NULL.

Protótipo da função:

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

Exemplos:

//cria um array com 50 elementos de 4 bytes
int v* = (int*) calloc(50, 4);

//cria um array com 50 elementos do tamanho de um char
int v* = (char*) calloc(50, sizeof(char));

Como falado anteriormente, caso a função tenha algum problema, ela retorna como resultado NULL, então é sempre interessante realizar uma validação para evitar erros.

int *p;
p = (int*) calloc(50, sizeof(int));
if(p == NULL){
	printf("Erro na alocação de memória!\n");
	exit(1);
}

As funções malloc e calloc são muito similares, a diferença, além dos argumentos que cada uma recebe, é que quando usamos a função calloc para fazer a alocaçãp, ela reserva o espaço na memória e completa esse espaço com zeros. Já a função malloc somente reserva o espaço na memória, o que faz com que você possa acabar acessando alguma informação que já estava lá (lixo de memória).

Função realloc()

A função realloc serve para alocar ou realocar memória durante a execução do programa. Ela recebe como parâmetro um ponteiro para um bloco de memória já alocado e a quantidade de bytes a ser alocada e retorna um ponteiro para a primeira posição do array. Caso não tenha espaço suficiente ou caso ocorra algum erro, ela retorna NULL.

Protótipo da função:

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

Exemplos:

//cria um array de 50 bytes
int *v = (int*) malloc(50);
//aumenta a memória alocada para 200 bytes
v = (int*) realloc(v,200);

Caso o ponteiro para o bloco de memória alocado seja NULL, a função irá alocar memória da mesma forma que a função malloc.

Exemplo:

//a linha abaixo executa a mesma coisa que a função malloc
int *p;
p = (int*) realloc(NULL, 50 * sizeof(char));

Caso o tamanho de memória solicitado seja 0, a função irá liberar o espaço de memória da mesma forma que a função free.

Exemplo:

int *v = (int*) malloc(50 * sizeof(int));
//a linha abaixo executa a mesma coisa que a função free
v = (int*) realloc(v, 0);

Caso o computador não tenha memória suficiente para alocar a memória solicitada, a função retorna NULL, esse é um ponto que merece atenção, pois caso ocorra algum problema as informações presentes no array podem ser perdidas, então, é aconselhável a utilização de uma variável para confirmar se a função obteve sucesso antes de salvar o resultado final.

Exemplo:

int *v = (int*) malloc(50 * sizeof(int));
int *v1 = (int*) realloc(v, 200 * sizeof(int));

if (v1 != NULL){
	v = v1;
}

Função free()

Por último mas não menos importante, a função free serve para liberar novamente o espaço de memória que foi alocado. Ela recebe como parâmetro o ponteiro para o endereço que será liberado novamente.

free(v);