C - Alocação dinâmica de memória

Olá galera, hoje mostrarei como funciona a alocação dinâmica de memória, em primeiro momento vamos entender a diferença da alocação estática para a dinâmica, basicamente a alocação estática é realizada antes do programa começar a ser executado, segue alguns exemplos de alocação estática:

int idade;                                                                                                                         

char nome[20]; 

 Mas as vezes você não sabe quanto precisará utilizar de memória, e é preciso alocar dinamicamente na execução do programa, para esse gerenciamento foram criadas as funções malloc(), calloc()  e free(). Para o uso dessas funções é necessária a declaração da biblioteca <stdlib.h> que pode ser incluída facilmente em seu header assim:

#include<stdlib.h>

Malloc

A função malloc (Memory Allocation) aloca um espaço na memória do computador e devolve o endereço. Como argumento é passado o tamanho de memória que se deseja alocar, por exemplo, se quiser alocar um espaço para uma variável inteira é simples com o uso do operador sizeof que retorna o tamanho de bytes necessários para uma variável de x tipo. Então ficaria assim:

int *idade;       

idade = (int*)  malloc(sizeof(int));

O endereço devolvido por malloc é do tipo *void, por isso foi necessário o cast(conversão).
Para atribuir valores a variáveis ponteiros digite o seguinte:

*idade = 13;

Há possibilidade de que sua memória esteja toda ocupada e não permita a alocação com malloc(), caso isso ocorra malloc retornará NULL, então é sempre bom verificar:

if(idade == NULL){
printf("Memória cheia!");
}else{
printf("Alocado com sucesso!");
}

Free

Quando se aloca uma variável estáticamente ela desaparece sempre após a execução da função. Contudo quando alocamos espaço dinamicamente esses valores são mantidos na memória. Para isso a função free existe, para liberar espaço de memória alocado dinamicamente, o que esta função basicamente faz é liberar o espaço alocado com malloc para que outros processos possam utilizar este local. Free irá receber como parametro o ponteiro alocado com malloc, essa é a sintaxe:

free(idade);

 Vetores e Matrizes 

Para a criação de vetores dinamicamente, existe a função calloc que irá receber dois parametros o primeiro será o  n, ou seja, o tamanho do vetor e por último o tamanho do byte que se deseja alocar assim como malloc,  observe o exemplo abaixo:

int n;
int *p;
scanf("%d", &n);
p = (int*) calloc(n, sizeof(int));

Lembrando que a norma ANSI não permite digitar "int v[n]", a menos que n seja uma constante. O que está sendo feito acima é uma alocação de memória dinamicamente, a leitura desse vetor é feita da mesma forma que faria caso tivesse declarado um vetor estático:

int i;
for(i = 0; i < n; ++i){
    scanf("%d", &p[i]);
}

Ou da seguinte forma, andando a cada endereço:

int i;
for(i = 0; i < n; ++i){
    scanf("%d", p+i);
}

A leitura também funciona da mesma forma:

int i;
for(i = 0; i < n; ++i){
    printf("%d", p[i]);//ou *p+i
} 

Lembrando que é possível a criação de vetores com malloc , da seguinte forma:

p = (int*) malloc(n * sizeof(int)); 

O que o código acima faz é, pedir que a memória aloque n espaços do tipo int, o que nada mais é do que um vetor.

A matriz segue na mesma linha da criação de vetores, a diferença é que será criado um vetor de vetores, com isso o seu ponteiro apontará para um ponteiro , segue exemplo abaixo:

int linhas,colunas,i;
int **matriz;
scanf("%d %d", &linhas,&colunas);
matriz = (int**) malloc( linhas * sizeof(int *));
for (i = 0; i < linhas; ++i)
matriz[i] = (int *) malloc (colunas * sizeof (int));

 O processo é simples , quando colocado dois asteristicos "**", significa que o seu ponteiro será um ponteiro para um ponteiro, que é o que precisamos para criar a nossa matriz bidimensional, lemos o número de linhas e depois o número de colunas, em primeiro momento é alocado o espaço para as linhas que serão os nossos ponteiros para cada coluna, e por último varremos todas as linhas e alocamos x colunas.

Para leitura ou escrita basta fazer do mesmo jeito, com a sintaxe matriz[i][j].

Obrigado por lerem mais uma aula de C, fiquem a vontade para perguntar nos comentários e até a próxima!