Memória Dinâmica (new/delete)

Parte da seção Programação Orientada a Objetos do Journey de C++ da Coddy. Lição 14 de 104.

Agora que você entende ponteiros e referências, vamos colocá-los em prática com alocação dinâmica de memória. Os operadores new e delete permitem que você crie e destrua objetos no heap em tempo de execução.

Use new para alocar memória e obter um ponteiro para ela:

int* num = new int;        // Aloca um único inteiro
*num = 42;                 // Atribui valor através do ponteiro

Player* player = new Player("Hero");  // Aloca um objeto

Cada new deve ter um delete correspondente para liberar a memória:

delete num;      // Libera um único objeto
delete player;   // Chama o destrutor e, em seguida, libera a memória

Para arrays, use new[] e delete[]:

int* scores = new int[5];    // Aloca um array de 5 inteiros
scores[0] = 100;

delete[] scores;             // Libera o array - note os colchetes!

Erros comuns a serem evitados:

// Vazamento de memória - esqueceu de deletar
int* ptr = new int(10);
ptr = new int(20);    // Perdeu o acesso à primeira alocação!

// Ponteiro pendente - usando após deletar
delete ptr;
*ptr = 5;             // Comportamento indefinido!

// Delete incompatível
int* arr = new int[10];
delete arr;           // Errado! Deveria ser delete[]

Após a exclusão, defina os ponteiros como nullptr para evitar o reuso acidental. O gerenciamento manual de memória é propenso a erros, razão pela qual o C++ moderno prefere ponteiros inteligentes, que exploraremos a seguir.

Desafio

Fácil

Vamos criar um sistema simples de armazenamento de mensagens que demonstra a alocação dinâmica de memória com new e delete.

Você criará dois arquivos para organizar seu código:

MessageBox.h: defina uma classe MessageBox que gerencie dinamicamente um array de mensagens. A classe deve ter:
- Um ponteiro privado para um array de strings alocado dinamicamente
- Um inteiro privado que acompanhe a quantidade atual de mensagens
- Um inteiro privado que armazene a capacidade máxima
- Um construtor que receba uma capacidade e aloque o array usando new[]
- Um destrutor que libere corretamente a memória usando delete[] e imprima "MessageBox destroyed"
- Um método addMessage(string msg) que adicione uma mensagem se houver espaço, retornando true em caso de sucesso ou false se estiver cheio
- Um método printAll() que imprima cada mensagem armazenada em sua própria linha
main.cpp: leia um valor de capacidade e uma quantidade de mensagens da entrada. Em seguida, leia essa quantidade de strings de mensagem. Crie um MessageBox no heap usando new, adicione todas as mensagens a ele, chame printAll() e então exclua corretamente o MessageBox para liberar a memória.

O formato da entrada será:

Primeira linha: a capacidade (inteiro)
Segunda linha: a quantidade de mensagens a adicionar (inteiro)
Linhas seguintes: uma mensagem por linha

Lembre-se: cada new precisa de um delete correspondente, e cada new[] precisa de um delete[] correspondente. Depois de excluir, é uma boa prática definir os ponteiros como nullptr.

Inclua o arquivo de cabeçalho em main.cpp usando #include "MessageBox.h".

Experimente você mesmo

#include <iostream>
#include <string>
#include "MessageBox.h"
using namespace std;

int main() {
    int capacity;
    int numMessages;
    
    // Lê a capacidade e o número de mensagens
    cin >> capacity;
    cin >> numMessages;
    cin.ignore(); // Limpa a nova linha após o número
    
    // TODO: Criar um MessageBox no heap usando new
    
    // TODO: Ler e adicionar todas as mensagens ao MessageBox
    for (int i = 0; i < numMessages; i++) {
        string message;
        getline(cin, message);
        // Adiciona a mensagem ao MessageBox
    }
    
    // TODO: Chamar printAll() para exibir todas as mensagens
    
    // TODO: Deletar o MessageBox para liberar memória
    // Lembre-se de definir o ponteiro como nullptr após deletar
    
    return 0;
}