Alocação Dinâmica em C

 
Por: Eduardo Casavella

Alocação Estática
 
Na alocação estática de memória, os tipos de dados tem tamanho predefinido. Neste caso, o compilador vai alocar de forma automática o espaço de memória necessário. Sendo assim, dizemos que a alocação estática é feita em tempo de compilação. Este tipo de alocação tende a desperdiçar recursos, já que nem sempre é possível determinar previamente qual é o espaço necessário para armazenar as informações. Quando não se conhece o espaço total necessário, a tendência é o programador exagerar pois é melhor superdimensionar do que faltar espaço.
 

Alocação Dinâmica
 
Na alocação dinâmica podemos alocar espaços durante a execução de um programa, ou seja, a alocação dinâmica é feita em tempo de execução. Isto é bem interessante do ponto de vista do programador, pois permite que o espaço em memória seja alocado apenas quando necessário. Além disso, a alocação dinâmica permite aumentar ou até diminuir a quantidade de memória alocada.
 

sizeof
 
A função sizeof determina o número de bytes para um determinado tipo de dados.

É interessante notar que o número de bytes reservados pode variar de acordo com o compilador utilizado.
 

Exemplo:

x = sizeof(int); //retorna 4 no gcc
 

malloc
A função malloc aloca um espaço de memória e retorna um ponteiro do tipo void para o início do espaço de memória alocado.
 

free
A função free libera o espaço de memória alocado.

 
Exemplo: Vetor Dinâmico
 
Quando um programador define tipo e o número de elementos um vetor ele está utilizando alocação estática.

Uma alternativa interessante é declarar um vetor como ponteiro, a fim de utilizar alocação dinâmica. Para tanto devemos usar a função malloc. Porém, esta função necessita saber a quantidade de bytes que devem ser reservados. Para fazer esse cálculo usamos o comando sizeof.
 

Vejamos como implementar esses detalhes no exemplo prático abaixo:

 

#include <stdio.h>
#include <stdlib.h> //necessário para usar as funções malloc() e free()
#include <conio.h>

int main(void)
{
    float *v; //definindo o ponteiro v
    int i, num_componentes;    
    
    printf("Informe o numero de componentes do vetor\n");
    scanf("%d", &num_componentes);
    
    /* ------------- Alocando dinamicamente o espaço necessário -------------
    
    1 - Calcular o número de bytes necessários
    primeiramente multiplicamos o número de componentes do vetor pela    
    quantidade de bytes que é dada pelo comando sizeof,
    portanto temos: 
             num_componentes * sizeof(float)
    
    2 - Reservar a quantidade de memória
    usamos malloc para reservar essa quantidade de memória,    
    então temos: 
          malloc(num_componentes * sizeof(float))
    
    3 - Converter o ponteiro para o tipo de dados desejado
    como a função malloc retorna um ponteiro do tipo void, 
    precisamos converter esse ponteiro para o tipo da nossa variável, no caso float,
    por isso usamos o comando de conversão explicita:
                                                   (float *)
    
    4 - juntando tudo e atribuindo em v temos o comando abaixo:   */
     
    v = (float *) malloc(num_componentes * sizeof(float));  
     
    //Armazenando os dados em um vetor
    for (i = 0; i < num_componentes; i++)
    {
      printf("\nDigite o valor para a posicao %d do vetor: ", i+1);
      scanf("%f",&v[i]);
    }   
    
   // ------ Percorrendo o vetor e imprimindo os valores ----------
   printf("\n*********** Valores do vetor dinamico ************\n\n");
   
   for (i = 0;i < num_componentes; i++)
   {
       printf("%.2f\n",v[i]);
   }       
   
   //liberando o espaço de memória alocado 
   free(v);
   
   getch();
   return 0;
}    

 

Tela de execução
 

Até a próxima!