Skip to content

Latest commit

 

History

History
95 lines (66 loc) · 3.53 KB

alocacao-dinamica-de-memoria.md

File metadata and controls

95 lines (66 loc) · 3.53 KB

Alocação Dinâmica de Memória

Entendo o uso de memória

Olhando para Layout de memória de um processo de execução no Linux.

  • User Stack = armazena todas as variáveis locais de uma função e também outros dados da função como registradores,endereços de retorno, etc.
  • Runtime heap = memória compartilhada por todos os processos em execução no sistema operacional, usado para a Alocação Dinâmica de Memória.
  • Read-Write segment = armazena todas as variáveis globais de um programa.
  • Read-only segment = armazena o código do programa.

Verificando o total de memória

  • Podemos no Linux verificar o quanto de memória temos para o programa usando o comando ulimit -a
core file size          (blocks, -c) 0
data seg size           (kbytes, -d) unlimited
scheduling priority             (-e) 0
file size               (blocks, -f) unlimited
...
stack size              (kbytes, -s) 8192 <--- ESTE AQUI
cpu time               (seconds, -t) unlimited
max user processes              (-u) 15333
virtual memory          (kbytes, -v) unlimited
file locks                      (-x) unlimited
  • Neste caso o tamanho da pilha é limitado a 8 Mb.

Alocação Dinâmica em C

Alocação Dinâmica de Memória resolve o problema de armazenar grandes quantidade de dados na pilha da memória. Também nos permite alocar memória que irá persistir além do escopo da função que estamos fazendo.

  • Lembre-se sempre que a Alocação Dinâmica de Memória usa a memória runtime heap.
  • Precisamos usar funções para gerenciar memória dinâmicamente.

Funções para gerência de memória

  • Usamos o Header stdlib.hpara mexermos com a alocação.
  • As seguintes funções são usadas dessa biblioteca:

Função malloc:

  • é a função mais simples! ela tenta alocar o número de bytes de memória e retorna um ponteiro para o bloco(se falhar vai dar NULL).
  • o número de bytes é o sizeof() do tipo de dado que queremos mais a multiplicação de quantas posições desejamos, por exemplo de um vetor.

Exemplo: criando um vetor de 10 posições em um ponteiro.

// Criando o Ponteiro com 10 espaços na memória
int* ptr = malloc(sizeof(int)*10);

// Criando de uma forma mais segura
int* ptr = malloc(10 * sizeof *ptr);

Função calloc:

  • A função calloc aloca memória para um array de tamanho definido onde cada posição requer um número definido de bytes.
  • O calloc inicia a memória com Zeros, onde o malloc não faz isso.
// Criando o Ponteiro com 10 espaços na memória
int* ptr = calloc(10, sizeof *ptr); //inicia tudo com zero

Função realloc:

  • A função realloc altera o tamanho de ponteiro já com a memória alocada.
  • Se é maior e não cabe, a função irá mover a memória para outro lugar e liberar o ponteiro original.
  • Retorna um ponteiro para o novo bloco que agora foi alocado.
// Ponteiro anteriormente alocado
int* ptr = calloc(10, sizeof *ptr);

// Aumentando o tamanho para mais 20
int* nptr = realloc(ptr, 30);

Liberando Memória:

  • Para liberar memória alocada dinâmicamente, precisamos chamar a função free para podermos liberar a memória para utilizar em outro lugar.
  • Precisamos passar o ponteiro que usamos para utilizar a memória alocada.
  • atenção, em C não existe Garbage Collection por isso precisamos sempre no final liberando a memória que não estamos mais usando dinâmicamente.
// Ponteiro com memória alocada
int* ptr = malloc(10 * sizeof *ptr);

// Liberando a memória
free(ptr);