AULA 19 - Programação 1 - Graduação

Alocação Dinâmica de Memória

Objetivos

• Anatomia de um programa em execução;
• Alocação dinâmica de memória.

A área de heap e o layout de memória de um programa C

Neste link podemos ter uma ideia da anatomia de um programa na memória do computador.

http://shivacherukuri.blogspot.com.br/2011/03/memory-layout-in-cdata-segmentbss-code.html

Podemos observar que existe as seguintes áreas:

• TEXT: área onde está o código;
• BSS: dados estaticamente alocados e não inicializados;
• DATA: dados estaticamente alocados e inicializados;
• STACK: área de pilha (variáveis locais);
• HEAP: área de dados alocados dinamicamente.

Quando declaramos uma variável global da forma:

 int x;

a variável x é alocada em uma área chamada BSS (dados não incializados). Note que x possui uma área de memória reservada a ela (4 bytes) e cuja existência é o tempo de vida do programa em execução.

Da mesma forma, uma variável global da forma:

 int y=10;

é alocada na área de DATA. A inicialização é definida normalmente na carga do programa. Os valores de inicialização são copiados para a área de DATA na carga do programa, a partir do arquivo executável.

Por vezes, o tamanho dos dados não são conhecidos antes da execução do programa. Neste caso, pode ser interessante criá-los dinamicamente e é neste ponto que entra a área de HEAP. Trata-se de uma área de memória, gerenciada a partir de funções da biblioteca do C.

As funções mais conhecidas são (http://en.wikipedia.org/wiki/C_dynamic_memory_allocation):

• malloc: aloca n bytes de memória;
• free: libera memória;
• realloc: realoca memória
• calloc:

http://www.linuxjournal.com/article/4681 http://www.cs.cmu.edu/~guna/15-123S11/Lectures/Lecture08.pdf

EXEMPLO 1

Alocação dinâmica de números inteiros (exercício puramente didático):

#include <stdlib.h>

main()
{
  int *px, *py;
  int resultado;
  px = (int *) malloc(sizeof(int));
  *px = 5;
  py = (int *) malloc(sizeof(int));
  *py = 2;
  resultado = *px + *py;

  free (px);
  px = NULL;
  free (py);
  py = NULL;
}

EXEMPLO 2

Vejamos comos diferentes elementos do programa são armazenados quando esse programa é executado. Os comentários no código explicam onde as variáveis ficam armazenadas.

int bss1;
static double bss2;
char *bss3;
// estas variáveis são armazenadas no segmento de dados não inicializado (BSS)
int init1=0;
float init2=10.0;
char *init3="Alo mundo!";
// estas variáveis são armazenadas no segmento de dados inicializados (DATA)
// o código para função principal é armazenado em (code segment)
int main()
{
	int local1=10; // esta variável é armazenada na pilha (stack) e código de inicialização é gerado pelo compilador.
	int local2; //esta variável não é inicializada, portanto, tem valor de lixo. Ela não fica inicializada com zero.
	static int local3; // esta é alocada no segmento BSS e é inicializada com zero.
	static int local4=100; //este é alocada e inicializada no segmento de dados
	int *loacl5=malloc(sizeof(int));
// esta variável é alocada na pilha no entanto, aponta para onde é alocada dinamicamente pelo bloco no heap.
return 0;
// stack frame para a função principal é destruída depois de executado o programa principal.
}

Alocando uma estrutura

#include <stdio.h>
#include <stdlib.h>
 
void main()
{
  struct TTeste{
     int x;
     int y;
  };
  
  struct TTeste *teste;
  

  
  teste = (struct TTeste *) malloc (sizeof(struct TTeste));
  if (teste==NULL) {
      printf("erro de alocação");
      exit(1);
  }
  
  teste->x=10;
  
  free(teste);
  
  teste=NULL;
}

Usando o typedef para ajudar na definição e declaração de estruturas

#include <stdio.h>
#include <stdlib.h>
 
void main()
{
  typedef struct {
     int x;
     int y;
  } TTeste;
  
  TTeste *teste;
  

  
  teste = (TTeste *) malloc (sizeof(TTeste));
  if (teste==NULL) {
      printf("erro de alocação");
      exit(1);
  }
  
  teste->x=10;
  
  free(teste);
  
  teste=NULL;
  
}

Alocando dinamicamente uma tabela de estruturas

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

void main()
{
  struct TTeste{
     int x;
     int y;
  } *teste;

  if ((teste = (struct TTeste *) malloc (100*sizeof(struct TTeste)))==NULL) {
      printf("erro de alocação");
      exit(1);
  }



  teste[10].x= 5;

  if ((teste = realloc(teste, 10000*sizeof(struct TTeste)))==NULL) {
      printf("erro de alocação");
      exit(1);
  }

  teste[9000].x=20;
  free(teste);

}

EXERCÍCIO

Refazer o exemplo anterior para que a quantidade de memória a ser alocada pela tabela seja passada na linha de comando.

<<	Aula 19	<>