I. Visão geral
Muitos programas de sistema precisam alocar memória adicional para estruturas de dados dinâmicas (listas vinculadas e árvores binárias) .O tamanho dessas estruturas de dados é determinado pelas informações obtidas em tempo de execução.
O processo pode alocar memória aumentando o tamanho da pilha. A chamada pilha é uma memória virtual contínua de comprimento variável, que começa no final do segmento de dados não inicializado do processo e aumenta ou diminui conforme a memória é alocada e liberado. Normalmente, a memória atual do heap é alterada. O limite é chamado de "interrupção do programa".
Dois: alocar memória no heap
1. Ajuste a interrupção do programa
#include <unistd.h>
int brk(void *addr);
void *sbrk(intptr_t increment);
Mudar o tamanho do heap é na verdade como instruir o kernel a mudar a posição de quebra do programa do processo. Depois que a posição de interrupção do programa é elevada, o programa pode acessar qualquer endereço de memória na área recém-alocada enquanto a página de memória física ainda não foi alocada. O kernel alocará automaticamente novas páginas de memória física quando o processo tentar pela primeira vez acessar esses endereços de memória virtual.
brk: A chamada do sistema irá definir a quebra do programa para a posição especificada pelo parâmetro addr.Como a memória virtual é alocada em unidades de páginas, addr será arredondado para o próximo limite da página de memória. Se o valor addr for inferior ao valor inicial e final, isso causará um comportamento imprevisível.
sbrk: aumenta o tamanho de entrada do incremento do parâmetro no endereço original da quebra do programa, e a chamada retorna com sucesso um ponteiro para o endereço inicial da memória recém-alocada.
2. malloc () e livre ()
#include <stdlib.h>
void *malloc(size_t size);
void free(void *ptr);
malloc: aloca memória do tamanho da subseção de tamanho de parâmetro no heap e retorna um ponteiro para o endereço inicial da memória recém-alocada. A memória alocada não foi inicializada.
free: O parâmetro ptr aponta para o bloco de memória, que geralmente é o valor de retorno da chamada malloc.
3. Calloc () e realloc ()
void *calloc(size_t nmemb, size_t size);
void *realloc(void *ptr, size_t size);
calloc: nmemb especifica o número de objetos alocados e size especifica o tamanho de cada objeto. O valor de retorno é um ponteiro para a memória. Se a alocação falhar, ele retornará NULL. A memória alocada por calloc foi inicializada para 0.
realocar: Ajuste o tamanho da memória com base na memória existente.
Ambas as chamadas de solicitação de memória acima são liberadas por free ().
4. Alocar memória alinhada: memalign () e posix_memalign ()
#include <stdlib.h>
int posix_memalign(void **memptr, size_t alignment, size_t size);
#include <malloc.h>
void *memalign(size_t alignment, size_t size);
Três: alocar memória na pilha
#include <alloca.h>
void *alloca(size_t size);
A chamada alloca () também pode alocar memória dinamicamente, mas em vez de alocar memória do heap, ela a aloca da pilha aumentando o tamanho do quadro de pilha. Você não pode usar o free para liberar, ele será liberado automaticamente quando a estrutura da pilha for removida.