Alocação de memória

O espaço de endereços de um processo em execução é dividido em várias áreas distintas. As mais importantes são:

Text: contém o código do programa e suas constantes. Esta área é alocada durante a chamada exec e permanece do mesmo tamanho durante toda a vida do processo.
Data e BSS: são as áreas onde o processo armazena suas variáveis globais e estáticas. Têm tamanho fixo durante a execução do processo.
Stack: contém a pilha de execução, onde são armazenadas os parâmetros, endereços de retorno e variáveis locais de funções. Pode variar de tamanho durante a execução do processo.
Heap: contém áreas de memória alocadas a pedido do processo, durante sua execução. Varia de tamanho durante a vida do processo.

Um programa em C suporta três tipos de alocação de memória:

A alocação estática ocorre quando são declaradas variáveis globais ou estáticas; geralmente usa a área Data.
A alocação automática ocorre quando são declaradas variáveis locais e parâmetros de funções. O espaço para a alocação dessas variáveis é reservado quando a função é invocada, e liberado quando a função termina. Geralmente é usada a pilha (stack).
A alocação dinâmica, quando o processo requisita explicitamente um bloco de memória para armazenar dados; o controle das áreas alocadas dinamicamente é manual ou semi-automático: o programador é responsável por liberar as áreas alocadas dinamicamente. A alocação dinâmica geralmente usa a área de heap.

Alocação estática

A alocação estática ocorrem com variáveis globais (alocadas fora de funções) ou quando variáveis locais (internas a uma função) são alocadas usando o modificador static. Uma variável alocada estaticamente mantém seu valor durante toda a vida do programa, exceto quando explicitamente modificada.

Exemplo:

estatica.c

#include <stdio.h>

int a = 0 ;  // variável global, aloc. estática

void incrementa ()

          int b = 0 ; // variável local, aloc. automática

   static int c = 0 ; // variável local, aloc. estática

   printf ("a: %d, b: %d, c: %d\n", a, b, c) ;

   a++ ;

   b++ ;

   c++ ;

int main ()

  int i ;

  for (i=0; i<5; i++)

    incrementa() ;

  return 0 ;

A execução desse código gera a seguinte saída:

a: 0, b: 0, c: 0

a: 1, b: 0, c: 1

a: 2, b: 0, c: 2

a: 3, b: 0, c: 3

a: 4, b: 0, c: 4

As variáveis com alocação estática (a e c) são alocadas e inicializadas uma única vez, portanto seus valores se preservam entre chamadas consecutivas da função incrementa. Por outro lado, a variável com alocação automática (b) é alocada e descartada a cada execução da função, portanto seu valor não é preservado.

Alocação automática

Por default, as variáveis definidas dentro de uma função (variáveis locais e parâmetros) são alocadas de forma automática na pilha de execução do programa (stack) a cada chamada da função, sendo descartadas quando a função encerra. Isso é o que ocorre com a variável b do código anterior.

Se a função for chamada recursivamente, as variáveis locais e parâmetros serão novamente alocados na pilha, em áreas distintas para cada nível de recursão. Isso permite preservar os valores anteriores dos mesmos no retorno dos níveis de recursão.

O exemplo a seguir permite observar a existência de múltiplas instâncias de variáveis locais (no caso, o parâmetro n) em chamadas recursivas:

fatorial.c

#include <stdio.h>

long int fatorial (int n)

  long int parcial ;

  printf ("antes:  n: %d\n", n) ;

  if (n < 2)

    parcial = 1 ;

  else

    parcial = n * fatorial (n - 1) ;

  printf ("depois: n: %d, parcial: %ld\n", n, parcial) ;

  return (parcial) ;

int main ()

  printf ("Fatorial (6) = %ld\n", fatorial (6)) ;

  return 0 ;

A execução gera o seguinte resultado:

antes:  n: 6

antes:  n: 5

antes:  n: 4

antes:  n: 3

antes:  n: 2

antes:  n: 1

depois: n: 1, parcial: 1

depois: n: 2, parcial: 2

depois: n: 3, parcial: 6

depois: n: 4, parcial: 24

depois: n: 5, parcial: 120

depois: n: 6, parcial: 720

Fatorial (6) = 720

O padrão C99 permite a alocação automática de vetores de tamanho variável, ou seja, definidos em tempo de execução. O exemplo a seguir ilustra esse conceito:

int my_function (int n)

   char name[n] ;  // aloca string com tamanho "n"

...

Alocação dinâmica

Na alocação dinâmica, o programa solicita explicitamente áreas de memória ao sistema operacional, as utiliza e depois as libera quando não forem mais necessárias, ou quando o programa encerrar. As requisições de memória dinâmica são geralmente alocadas na área de memória denominada heap.

CURIOSIDADE:

Alocação simples

A memória pode ser alocada dinamicamente através da chamada malloc:

#include <stdlib.h>

void * malloc (size_t size)

Esta função aloca uma nova região com size bytes de tamanho e retorna um ponteiro para o início da mesma (ou 0 em caso de erro). O conteúdo dessa nova área é indefinido (ou seja, pode conter “lixo”).

Exemplo de uso:

struct mystruct *ptr;

...

ptr = malloc (sizeof (struct mystruct));

if (ptr == 0) abort (); // caso a alocação não tenha ocorrido

Liberação

A chamada free deve ser invocada para liberar uma área de memória previamente alocada dinamicamente:

#include <stdlib.h>

void free (void *ptr)

Esta função libera um bloco de memória previamente alocado, apontado por ptr. É importante observar que o ponteiro ptr continua apontando para a área liberada, por isso é aconselhável mudar seu valor para NULL após a liberação:

ptr = malloc (1024) ;

...

free (ptr) ;

ptr = NULL ; // não é obrigatório, mas aconselhado

Redimensionamento de área alocada

#include <stdlib.h>

void * realloc (void *ptr, size_t newsize)

Esta função redimensiona o bloco previamente alocado apontado por ptr para o novo tamanho newsize. Retorna o novo endereço do bloco, que pode ser diferente do anterior, caso tenha sido necessário mudá-lo de lugar (o conteúdo original do bloco é preservado nesse caso ou em caso de erro).

Alocação de vetor

#include <stdlib.h>

void * calloc (size_t count, size_t eltsize)

Esta função aloca um bloco de memória de tamanho suficiente para conter um vetor com count elementos de tamanho eltsize cada um. O conteúdo do bloco alocado é preenchido por zeros.

Exemplo:

float *v ;

int i ;

v = calloc (10000, sizeof(float)) ;

for (i=0; i< 10000; i++)

  v[i] = 1.0 / (i + 1) ;

Alocação semiautomática

#include <stdlib.h>

void * alloca (size_t size)

Esta função provê um mecanismo de alocação dinâmica semi-automática, ou seja, o bloco é alocado manualmente, mas será liberado automaticamente ao encerrar a função onde ele foi alocado. O valor de retorno da chamada é o endereço de um bloco de tamanho size bytes, alocado na pilha da função atual (como se fosse uma variável local).

Inicialização

O conteúdo inicial de variáveis não-inicializadas depende da forma como são alocadas. A tabela a seguir resume as principais possibilidades:

Alinhamento de memória

Os blocos alocados pelas funções acima geralmente iniciam em um endereço múltiplo de 8 bytes em plataformas de 32 bits. Caso seja necessário garantir a alocação alinhada, obtendo blocos iniciando em múltiplos de 8, 16, 32, 64 bytes, etc, a função a seguir está disponível:

#include <malloc.h>

void * memalign (size_t boundary, size_t size)

Aloca um bloco de tamanho size cujo endereço inicial é um múltiplo de boundary (que deve ser 2ⁿ). Retorna o endereço do bloco alocado, que pode ser liberado mais tarde através da função free. Ver também a função posix_memalign.

fonte: http://wiki.inf.ufpr.br/maziero/doku.php?id=prog2:alocacao_de_memoria&do=edit

Heap vs stackQual a diferença entre alocação de memória feita no Heap ou na pilha de funções (stack)