Alocação Dinâmica de Memória

Existem dois tipos de memória disponíveis para uso: stack e heap. A memória stack é limitada em tamanho e é bem adequada para variáveis pequenas e de curta duração que não são necessárias além de seu escopo. Quando uma variável armazenada na stack sai do escopo, ela é automaticamente destruída.

stack_allocated


              12
            
// Creates an integer variable on the stack
int stack_int = 42;

No entanto, quando você precisa de memória que persista além de seu escopo ou que requeira mais espaço, você recorre ao heap. O heap é um pool de memória muito maior onde seu programa pode solicitar memória em tempo de execução. Isso é tipicamente feito usando a palavra-chave new:

heap_allocated


              12
            
// create an integer on the heap
int* heap_int = new int;

A questão complicada sobre a memória heap é que ela não é liberada automaticamente. É responsabilidade do desenvolvedor desalocá-la quando terminar. Para cada new, deve haver um delete correspondente.

free_pointer


              12
            
// Explicitly deletes the integer on the heap
delete heap_int;

Vazamentos de Memória

Quando você introduz ponteiros no seu código, você entra no reino da gestão manual de memória. A gestão manual de memória requer que você libere a memória quando ela não é mais necessária. Isso pode levar a armadilhas comuns: vazamentos de memória e ponteiros pendentes.

Vazamentos de memória geralmente ocorrem quando você esquece de desalocar a memória. Essa memória permanece reservada, fazendo com que seu programa perca memória ao longo do tempo.

memory_leak


              12345
            
running = true
while (running)
{
    int* p_int = new int;
}

Ponteiros Pendentes

Ponteiros pendentes ocorrem quando um ponteiro continua apontando para uma memória que foi desalocada. É como ter um mapa do tesouro que leva você a um lugar (endereço de memória) onde o tesouro (dados) já foi retirado (destruído).

main


              12345678910111213
            
#include <iostream>

int main()
{
    int* ptr = new int; // dynamically allocate an integer

    *ptr = 42; // assign a value to the allocated memory
    std::cout << *ptr << std::endl; // This will output 42

    delete ptr; // deallocate the memory

    std::cout << *ptr << std::endl; // ptr is a dangling pointer!
}

Tentando acessar um ponteiro após chamar delete nele, o que desaloca a memória para a qual ele estava apontando. Após a exclusão, o ponteiro se torna um ponteiro pendente, pois ainda mantém o endereço de uma memória que não existe mais.

Acessar um ponteiro pendente pode levar a um comportamento imprevisível ou até mesmo a falhas, já que a memória para a qual ele aponta não é mais válida.

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 1. Capítulo 2