Alocação Dinâmica de Memória em C

Funções de manipulação de memória

A linguagem C oferece um conjunto de funções que permitem alocar memória dinamicamente, trazendo bastante flexibilidade para a construção de estruturas de dados mais complexas e eficientes. As funções mais importantes são descritas abaixo e estão disponíveis na biblioteca stdlib.

Função	Descrição
malloc(numDeBytes)	Retorna um apontador para uma variável dinâmica como tamanho especificado como parâmetro. Uma situação bastante comum é utilizar a função sizeof para calcular o número de bytes a serem alocados baseando-se no tipo do dado. Exemplo: int vetInt[] = (int) maloc(sizeof(int) NUM_ELEMENTOS)
free(ptr)	Desaloca da memória a variável dinâmica apontada pelo apontador ptr passado como parâmetro.
realloc(ptr, numDeBytes)	Modifica o tamanho da variável dinâmica previamente alocada e apontada por ptr para o novo valor especificado pelo parâmetro numDeBytes. Este pode ser maior ou menor que o anterior. Retorna um apontador, já que pode ser preciso mover os dados para um novo bloco de memória ao aumentar se tamanho. Caso isto ocorra, o conteúdo da variável antiga é copiada para o novo bloco, ou seja, nenhuma informação é perdida. Se ptr for NULL, aloca uma variável do tamanho determinado por numDeBytes e devolve um ponteiro; Se numDeBytes for zero, a memória apontada por ptr é liberada (semelhante a chamar free). Se não houver memória suficiente para a alocação, um ponteiro nulo é devolvido e o bloco original é deixado inalterado.

Exemplo 1 (programa que aloca blocos de memória até não haver memória disponível):

#include <stdio.h>
#include <stdlib.h>

int main (){

   long *p;

   long num;
   printf("\nDigite o tamanho inicial do vetor-->");
   scanf("%d", &num);

   do
   {
      p=(long *)malloc(num*sizeof(long));

      if (!p)
      {
         printf ("** \n\nErro: Memoria Insuficiente\n\n **");
         getch();
      }
      else
      {
         printf ("** \n\nMemoria Alocada com Sucesso %d bytes\n\n **", num*sizeof(long));
      }
   }
   while (p);
   return (0);
}

Exemplo 2: Programa que cria e manipula uma lista encadeada

#include <stdio.h>
#include <stdlib.h>

struct no {
   int valor;
   struct no *prox;
};

// Definicao de um tipo de dados chamado noLista
typedef struct no noLista;

void insere(int x, noLista *p)
{
   noLista *nova;
   nova = (noLista*) malloc( sizeof (noLista));
   (*nova).valor = x;
   nova->prox = (*p).prox;
   p->prox = nova;
}

noLista* busca( int x, noLista *ini)
{
   noLista *p;
   p = ini->prox;
   while ((p != NULL) && (p->valor != x))
      p = p->prox;
   return p;
}

void remover(noLista *p)
{
   noLista *noApagar = p->prox;
   p->prox = noApagar->prox;
   free(noApagar);
}

void imprime(noLista *cab)
{
   noLista *p;
   p = cab->prox;
   while (p != NULL)
   {
      printf("%d ", (int) p->valor);
      p = p->prox;
   }
}

void apagarLista(noLista *cab)
{
   while(cab->prox != NULL)
   {
      printf(" removendo %d ", cab->prox->valor);
      remover(cab);
   }

}

int main()
{
   noLista cabeca;
   cabeca.prox = NULL;

   int i;
   for (i = 1; i<= 100; i++) 
   {
      insere(i, &cabeca);
   }
 
   imprime(&cabeca);

   noLista *p = busca(50, &cabeca);
   if (p)
   {
      printf("\n50 foi encontrado\n");
   }
   else
   {
      printf("\n50 nao foi encontrado\n");
   }

   apagarLista(&cabeca);
}