Gerenciamento de Memória com New e Delete

Gerenciamento de Memória com New e Delete

Em C++, você pode criar variáveis de duas formas: na pilha (stack) ou no heap. Variáveis normais são criadas na pilha e desaparecem automaticamente. Mas às vezes você precisa de memória que dure enquanto você quiser — é aí que entram os operadores new e delete.

O que é o Heap?

O heap é uma área de memória onde você pode alocar espaço dinamicamente. Diferente da pilha, a memória no heap não é liberada automaticamente. Você é responsável por liberar essa memória quando não precisar mais dela.

Usando o Operador New

O operador new aloca memória no heap e retorna um ponteiro para essa memória. Um ponteiro é um endereço de memória.

// Alocando um inteiro no heap
int* numero = new int;
*numero = 42;  // Atribuindo valor através do ponteiro

std::cout << *numero;  // Imprime: 42

Vamos entender o código:

• int* — declara um ponteiro para inteiro
• new int — aloca memória para um inteiro no heap
• *numero — acessa o valor apontado pelo ponteiro (desreferenciação)

Usando o Operador Delete

Quando você termina de usar a memória alocada, deve liberá-la com delete. Isso devolve a memória ao sistema.

int* numero = new int;
*numero = 42;

std::cout << *numero;  // Funciona normalmente

delete numero;  // Libera a memória
numero = nullptr;  // Boa prática: aponta para nulo

Por que atribuir nullptr após delete? Isso evita que você use acidentalmente um ponteiro que aponta para memória já liberada (chamado "dangling pointer").

Alocando Arrays

Você também pode alocar arrays dinamicamente:

// Alocando um array de 5 inteiros
int* array = new int[5];

array[0] = 10;
array[1] = 20;
array[2] = 30;

// Liberando array (note os colchetes!)
delete[] array;
array = nullptr;

Atenção: Use delete[] para arrays e delete para valores únicos. Usar o errado causa problemas!

Alocando Objetos

Você pode alocar objetos customizados também:

class Pessoa {
public:
    std::string nome;
    int idade;
};

Pessoa* p = new Pessoa;
p->nome = "João";  // Use -> para acessar membros
p->idade = 25;

delete p;
p = nullptr;

Exemplo Completo

#include <iostream>
using namespace std;

int main() {
    // Alocando memória
    int* x = new int;
    *x = 100;
    
    cout << "Valor: " << *x << endl;
    cout << "Endereço: " << x << endl;
    
    // Liberando memória
    delete x;
    x = nullptr;
    
    return 0;
}

Boas Práticas

• Sempre libere a memória: Se você usa new, use delete correspondente
• Defina como nullptr: Após deletar, atribua nullptr ao ponteiro
• Use delete[] para arrays: Não use delete simples em arrays
• Evite vazamento de memória: Memória não liberada fica perdida e consome recursos

Erros Comuns

Erro 1: Esquecer de deletar

int* x = new int;  // Aloca memória
*x = 50;
// Esqueceu de delete! Vazamento de memória

Erro 2: Usar delete errado

int* array = new int[10];
delete array;  // ERRADO! Deveria ser delete[]

Erro 3: Usar após deletar

int* x = new int;
delete x;
*x = 50;  // ERRO! Ponteiro inválido