Programar em C/Gerenciamento de memória

Origem: Wikilivros, livros abertos por um mundo aberto.
Saltar para a navegação Saltar para a pesquisa

Alocação dinâmica[editar | editar código-fonte]

Todos os dados de um programa são armazenados na memória do computador; é muito comum necessitar reservar um certo espaço na memória para poder guardar dados mais tarde. Por exemplo, poderíamos reservar um espaço de 1000 bytes para guardar uma string que o usuário viesse a digitar, declarando um vetor de 1000 caracteres. E se quiséssemos reservar um espaço que só é conhecido no tempo de execução do programa? E se o espaço fosse muito grande, de modo que declarar vetores de tal tamanho seria inconveniente (pois, entre outras coisas, aumenta sem necessidade o tamanho do executável)?

Para solucionar esse problema, existe a alocação dinâmica de memória, que como o nome sugere, é uma maneira de alocar memória à medida que o programa vai sendo executado. As quatro funções relacionadas com a alocação dinâmica serão descritas a seguir.

malloc e free[editar | editar código-fonte]

Essas duas funções são as mais básicas para o gerenciamento de memória. malloc é responsável pela alocação de um pedaço de memória, e free é responsável por liberar esse pedaço de memória.

A função malloc() serve para alocar memória e tem o seguinte protótipo:

void *malloc (unsigned int num);
void free (void * ptr);

Para alocar um espaço na memória, precisamos fornecer à função malloc o número de bytes desejados. Ela aloca na memória e retorna um ponteiro void * para o primeiro byte alocado. O ponteiro void* pode ser atribuído a qualquer tipo de ponteiro. Se não houver memória suficiente para alocar a memória requisitada a função malloc() retorna um ponteiro nulo.

Para saber o tamanho do bloco a alocar, precisaremos usar o operador sizeof. Ele permite também saber automaticamente o tamanho de structs criadas pelo usuário.

Veja um exemplo de alocação dinâmica:

 #include <stdio.h>
 #include <stdlib.h>
   
 int main(int argc, char *argv[])
 {
   
   /* ponteiro para memória que será alocada */
   int *p;
   int i;
   
   /* alocar 10 elementos inteiros, ou seja, ( sizeof (int) * 10 ) */
   p = (int *) malloc ( sizeof (int) * 10);
         
   if ( p == NULL ) {
      printf ("Erro: Não foi possivel alocar memória\n");
      exit(1);
   }
      
   for(i = 0; i < 10; i++) {
     p[i] = i * 2;
     printf ("%d\n", p[i]);
   }
   
   /* libera a memória alocada por malloc */
   free (p);
   
   return 0;
 }

Outros exemplos:

int main()
{
   int *p, *q;
   p = malloc(sizeof(int));
   q = p;
   *p = 10;
   printf("%d\n", *q);
   *q = 20;
   printf("%d\n", *q);
}
int main()
{
    int *p, *q;
    p = malloc(sizeof(int));
    q = malloc(sizeof(int));
    *p = 10;
    *q = 20;
    *p = *q;
    printf("%d\n", *p);
}
  • O compilador aceita *p=*q porque são ambos int.
  • O compilador aceita também p=q porque ambos são ponteiros e apontam para o mesmo tipo.
  • Podemos simplificar p = malloc(sizeof(int)); por p = malloc(4); mas como temos sistemas operacionais de 16,32, 64 bits a primeira declaração torna as coisas mais portáveis.

calloc[editar | editar código-fonte]

A função calloc() também serve para alocar memória, mas possui um protótipo um pouco diferente:

    void *calloc(size_t nelem, size_t elsize);

A função calloc reserva um bloco com o tamanho (nelem x elsize) octetos consecutivos, isto é, aloca memória suficiente para um vetor de num objetos de tamanho size. Diferente de malloc(), o bloco reservado é inicializado a 0. Essa função retorna um ponteiro void* para o primeiro byte alocado. O ponteiro void* pode ser atribuído a qualquer tipo de ponteiro. Se não houver memória suficiente para alocar a memória requisitada a função calloc() retorna um ponteiro nulo.

Exemplo:

#include <stdio.h>
#include <stdlib.h>  /* Para usar calloc() */

int main (){
    int *p;
    int n;
    int i;
    ...                        /* Determina o valor de n em algum lugar */
    p = calloc(n, sizeof(int));      /* Aloca n números inteiros p pode agora ser tratado como um vetor com n posicoes */
    //p = malloc(n*sizeof(int));  /* Maneira equivalente usando malloc. */
    if (!p)
    {
       	printf ("** Erro: Memoria Insuficiente **");
       	exit(0);
    }
    for (i=0; i<n; i++)        /* p pode ser tratado como um vetor com n posicoes */
         p[i] = i*i;
    ...
    return 0;
 }

No exemplo acima, é alocada memória suficiente para se colocar n números inteiros. O operador sizeof() retorna o número de bytes de um inteiro. Ele é útil para se saber o tamanho de tipos. O ponteiro void * que calloc() retorna é convertido para um int* pelo cast e é atribuído a p. A declaração seguinte testa se a operação foi bem sucedida. Se não tiver sido, p terá um valor nulo, o que fará com que !p retorne verdadeiro. Se a operação tiver sido bem sucedida, podemos usar o vetor de inteiros alocados normalmente, por exemplo, indexando-o de p[0] a p[(a-1)].

realloc[editar | editar código-fonte]

A função realloc() serve para realocar memória e tem o seguinte protótipo:

   void *realloc(void *ptr, size_t size);

A função realloc ajusta o tamanho de um bloco a size octetos consecutivos. A função modifica o tamanho da memória previamente alocada com malloc, calloc ou realloc e apontada por ptr para o tamanho especificado por size. O valor de size pode ser maior ou menor que o original. Um ponteiro para o bloco é devolvido porque realloc() pode precisar mover o bloco para aumentar seu tamanho. Se isso ocorrer, o conteúdo do bloco antigo é copiado no novo bloco, o bloco antigo é liberado e nenhuma informação é perdida. Se não precisar mover, o valor retornado é igual a ptr. Se ptr for nulo, a função aloca size bytes e devolve um ponteiro, funcionando como malloc(); se size é zero, a memória apontada por ptr é liberada. Se não houver memória suficiente para a alocação, um ponteiro nulo é devolvido e o bloco original é deixado inalterado.

Exemplo:

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

int main() {
    char *str1=NULL, *str2=NULL;

    str1 = (char *) malloc(11);
    strcpy(str1, "ABCDEFGHIJ");

    str2 = (char *) realloc(str2, 20);

    printf("Endereço de str1 : %p\n", str1);
    printf("Endereço de str2 : %p\n", str2);

    str1 = (char *) realloc(str1, 100);

    printf("Novo endereço de str1 : %p\n", str1);
    printf("Conteudo de str1 : %s\n", str1);
    free(str1);
    free(str2);
    return 0;
}

Alocação Dinâmica de Vetores[editar | editar código-fonte]

A alocação dinâmica de vetores utiliza os conceitos aprendidos na aula sobre ponteiros e as funções de alocação dinâmica apresentados. Um exemplo de implementação para vetor real é fornecido a seguir:

 #include <stdio.h>
 #include <stdlib.h>
 float *Alocar_vetor_real (int n)
 {
   float *v;        			           /* ponteiro para o vetor */
   if (n < 1) 
    {  			                           /* verifica parametros recebidos */
      printf ("** Erro: Parametro invalido **\n");
      return (NULL);
    }
  v = calloc (n, sizeof(float));         /* aloca o vetor */
  if (v == NULL) 
   {
     printf ("** Erro: Memoria Insuficiente **");
     return (NULL);
   }
  return (v);    			           /* retorna o ponteiro para o vetor */
 }
 float *Liberar_vetor_real (float *v)
 {
   if (v == NULL) return (NULL);
   free(v);        			          /* libera o vetor */
   return (NULL);  			          /* retorna o ponteiro */
 }
 int main (void)
 {
   float *p;
   int a;
   ...    				/* outros comandos, inclusive a inicializacao de a 

*/
   p = Alocar_vetor_real (a);
   ...    				/* outros comandos, utilizando p[] normalmente */
   p = Liberar_vetor_real (p);
 }

Alocação Dinâmica de Matrizes[editar | editar código-fonte]

A alocação dinâmica de memória para matrizes é realizada da mesma forma que para vetores, com a diferença que teremos um ponteiro apontando para outro ponteiro que aponta para o valor final, ou seja é um ponteiro para ponteiro, o que é denominado indireção múltipla. A indireção múltipla pode ser levada a qualquer dimensão desejada, mas raramente é necessário mais de um ponteiro para um ponteiro. Um exemplo de implementação para matriz real bidimensional é fornecido a seguir. A estrutura de dados utilizada neste exemplo é composta por um vetor de ponteiros (correspondendo ao primeiro índice da matriz), sendo que cada ponteiro aponta para o início de uma linha da matriz. Em cada linha existe um vetor alocado dinamicamente, como descrito anteriormente (compondo o segundo índice da matriz).

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

float **Alocar_matriz_real (int m, int n)
{
    float **v;                             /* ponteiro para a matriz */
    int   i;                               /* variavel auxiliar      */
    if (m < 1 || n < 1) 
    {                                      /* verifica parametros recebidos */
        printf ("** Erro: Parametro invalido **\n");
         return (NULL);
    }                                   /* aloca as linhas da matriz */
    v = calloc (m, sizeof(float *));      /*Um vetor de m ponteiros para float */
    if (v == NULL)
    {
         printf ("** Erro: Memoria Insuficiente **");
         return (NULL);
    }					
    for ( i = 0; i < m; i++ )           /* aloca as colunas da matriz */
    {
         v[i] = calloc (n, sizeof(float));    /* m vetores de n floats */
         if (v[i] == NULL) 
         {
             printf ("** Erro: Memoria Insuficiente **");
             return (NULL);
         }
    }
    return (v); 					/* retorna o ponteiro para a matriz */
}

float **Liberar_matriz_real (int m, int n, float **v)
{
    int  i;                       /* variavel auxiliar */
    if (v == NULL) return (NULL);
    if (m < 1 || n < 1) 
    {                      /* verifica parametros recebidos */
        printf ("** Erro: Parametro invalido **\n");
        return (v);
    }
    for (i=0; i<m; i++) free (v[i]);    /* libera as linhas da matriz */
    free (v);                         /* libera a matriz (vetor de ponteiros) */
    return (NULL);                  /* retorna um ponteiro nulo */
}

int main (void)
{
    float **mat;       /* matriz a ser alocada */
    int   l, c;         /* numero de linhas e colunas da matriz */
    int i, j;
    ...                 /* outros comandos, inclusive inicializacao para l e c */
    mat = Alocar_matriz_real (l, c);
    for (i = 0; i < l; i++)
      for ( j = 0; j < c; j++)
         mat[i][j] = i+j;
    ...                    /* outros comandos utilizando mat[][] normalmente */
    mat = Liberar_matriz_real (l, c, mat);
    ...
}