Liberando Memória com 'delete'

Parte da seção Lógica & Fluxo do Journey de C++ da Coddy — lição 7 de 56.

Quando você aloca memória dinamicamente usando new, essa memória não desaparece automaticamente quando você termina de usá-la. Ao contrário das variáveis comuns que são limpas automaticamente, a memória alocada dinamicamente permanece em uso até que você a libere explicitamente. É aqui que a palavra-chave delete se torna essencial.

A palavra-chave delete desaloca a memória que foi previamente alocada com new. Quando você usa delete, você está dizendo ao sistema que terminou de usar essa memória e que ela pode ser reutilizada para outros fins:

int* ptr = new int(42);  // Alocar memória
// Usar a memória...
delete ptr;              // Liberar a memória

A regra fundamental do gerenciamento de memória dinâmica é simples: para cada new, deve haver um delete correspondente. Se você esquecer de deletar a memória alocada dinamicamente, você cria um vazamento de memória - seu programa continua retendo memória que não está mais usando, o que pode eventualmente fazer com que seu sistema fique sem memória disponível.

Após chamar delete em um ponteiro, esse ponteiro torna-se inválido e não deve ser usado novamente. É uma boa prática definir o ponteiro como nullptr após a exclusão para evitar usá-lo acidentalmente.

Desafio

Fácil

Crie um programa que demonstre o ciclo de vida completo da memória dinâmica, alocando memória com new, utilizando-a e, em seguida, desalocando-a adequadamente com delete.

As seguintes entradas serão fornecidas:

Um valor inteiro para armazenar na memória alocada dinamicamente
Um segundo valor inteiro para atualizar o valor armazenado

Seu programa deve:

Usar new para alocar memória dinamicamente para um inteiro e armazenar o ponteiro em uma variável chamada dynamicPtr
Atribuir o primeiro valor de entrada à memória alocada dinamicamente usando o operador de desreferência
Imprimir o valor inicial armazenado na memória alocada dinamicamente
Atualizar o valor na memória alocada dinamicamente para o segundo valor de entrada
Imprimir o valor atualizado
Usar delete para liberar a memória alocada dinamicamente
Definir o ponteiro como nullptr após a exclusão
Imprimir uma mensagem de confirmação de que a memória foi liberada

Use o seguinte formato de saída exato:

Initial value: [first value]
Updated value: [second value]
Memory freed successfully

Folha de consulta

A palavra-chave delete desaloca memória que foi previamente alocada com new:

int* ptr = new int(42);  // Aloca memória
// Usa a memória...
delete ptr;              // Libera a memória

Para cada new, deve haver um delete correspondente para evitar vazamentos de memória.

Após chamar delete, defina o ponteiro como nullptr para evitar o uso acidental de memória inválida:

delete ptr;
ptr = nullptr;

Experimente você mesmo

#include <iostream>
using namespace std;

int main() {
    // Ler valores de entrada
    int firstValue, secondValue;
    cin >> firstValue;
    cin >> secondValue;
    
    // TODO: Escreva seu código abaixo
    // 1. Alocar memória usando new e armazenar em dynamicPtr
    // 2. Atribuir firstValue à memória alocada
    // 3. Imprimir o valor inicial
    // 4. Atualizar com secondValue
    // 5. Imprimir o valor atualizado
    // 6. Deletar a memória e definir o ponteiro como nullptr
    // 7. Imprimir mensagem de confirmação
    
    return 0;
}

Teste seus conhecimentos

Esta lição inclui um quiz rápido. Comece a lição para respondê-lo e acompanhar seu progresso.

Todas as lições de Lógica & Fluxo

3Projeto: Ferramenta de Lista de Tarefas

Visão Geral do Projeto Adicionando uma Tarefa

Visualizando Tarefas

Removendo uma Tarefa

Finalizando a Ferramenta

6Conjuntos (Elementos Únicos)

Apresentando o std::set Criar Conjunto e Adicionar Elementos Verificando Elementos Removendo Elementos Iterando sobre um Conjunto Recapitulação - Números Únicos

9Desafios Finais

Filtragem de Dados em Vetores Busca de Valores em Mapas Ponteiro e Array Dinâmico