Análisis detallado del destructor

Parte de la sección Programación Orientada a Objetos del Journey de C++ de Coddy. Lección 24 de 104.

Un destructor es una función miembro especial que se ejecuta automáticamente cuando se destruye un objeto. Su función principal es liberar los recursos que el objeto adquirió durante su vida útil, como memoria asignada dinámicamente, identificadores de archivos o conexiones de red.

El destructor tiene el mismo nombre que la clase, precedido por una tilde ~. No recibe parámetros y no tiene tipo de retorno:

class FileHandler {
    std::string filename;
    int* buffer;
public:
    FileHandler(std::string name, size_t size) 
        : filename(name), buffer(new int[size]) {
        std::cout << "Opening " << filename << "\n";
    }
    ~FileHandler() {
        delete[] buffer;
        std::cout << "Closing " << filename << "\n";
    }
};

Los destructores se llaman automáticamente en estas situaciones:

Los objetos de la pila salen de ámbito
Se llama a delete sobre un objeto asignado en el heap
Finaliza la vida útil de un objeto temporal

void example() {
    FileHandler f1("data.txt", 100);    // Se llama al constructor
    FileHandler* f2 = new FileHandler("log.txt", 50);
    delete f2;                           // Se llama al destructor de f2
}   // Se llama al destructor de f1 (sale del ámbito)

A diferencia de los constructores, una clase solo puede tener un destructor. No puedes sobrecargarlo.

Si no defines uno, el compilador genera un destructor predeterminado que no hace nada especial: simplemente destruye cada miembro. Para las clases que administran recursos, debes escribir el tuyo para evitar fugas de memoria.

Desafío

Fácil

Vamos a crear un administrador de sesiones que registre las sesiones de usuario activas y demuestre cómo los destructores limpian automáticamente los recursos cuando se destruyen los objetos, ya sea al salir del ámbito o al eliminarlos explícitamente.

Crearás dos archivos para organizar tu código:

Session.h: Define una clase Session que representa una sesión de usuario activa con datos asignados dinámicamente. Tu clase debe tener:
- Miembros privados: un username (string), un sessionId (int) y un puntero a un arreglo de enteros llamado activityLog que registre las acciones del usuario, junto con un logSize para el tamaño del arreglo
- Un constructor que reciba un nombre de usuario, un ID de sesión y el tamaño del registro. Debe asignar el arreglo del registro de actividad en el heap, inicializar todos los elementos a 0 e imprimir "Session <sessionId> started for <username>"
- Un destructor que libere la memoria asignada e imprima "Session <sessionId> ended for <username>"
- Un método logActivity(int activityCode) que almacene el código de actividad en la siguiente posición disponible (lleva la cuenta interna de la posición actual); si el registro ya está lleno, se ignora la llamada, por lo que el recuento nunca supera el tamaño del registro
- Un método getActivityCount() que devuelva cuántas actividades se han registrado
- Un método getUsername() que devuelva el nombre de usuario
main.cpp: Demuestra el comportamiento de los destructores en distintos escenarios. Lee un nombre de usuario y el tamaño del registro desde la entrada (cada uno en una línea separada) y luego:
- Crea un bloque de ámbito con llaves { } y dentro crea una Session asignada en la pila con el nombre de usuario de la entrada, el ID de sesión 101 y el tamaño del registro de la entrada. Registra dos actividades con los códigos 1 y 2, y luego imprime "Stack session activities: <count>". Cuando termina el bloque, el destructor debe ejecutarse automáticamente.
- Después del bloque, imprime "Stack session destroyed"
- Crea una Session asignada en el heap usando new con el nombre de usuario "Guest", el ID de sesión 202 y el tamaño del registro 3. Registra una actividad con el código 5, imprime "Heap session activities: <count>" y luego elimínala explícitamente con delete.
- Después de eliminarla, imprime "Heap session destroyed"

Este desafío muestra las dos formas principales en que se llaman los destructores: automáticamente cuando los objetos de la pila salen del ámbito y manualmente cuando eliminas objetos del heap. Ambas vías deben liberar correctamente el registro de actividad asignado dinámicamente para evitar fugas de memoria.

Incluye tu archivo de encabezado en main.cpp usando #include "Session.h".

Pruébalo tú mismo

#include <iostream>
#include <string>
#include "Session.h"

using namespace std;

int main() {
    // Lee la entrada
    string username;
    int logSize;
    getline(cin, username);
    cin >> logSize;
    
    // TODO: Crea un bloque de ámbito con llaves { }
    // Dentro del bloque:
    //   - Crea una Session en la pila con el nombre de usuario de entrada, el ID de sesión 101 y el tamaño de registro de entrada
    //   - Registra dos actividades con los códigos 1 y 2
    //   - Imprime "Stack session activities: <count>"
    // Cuando termina el bloque, el destructor se ejecuta automáticamente
    
    // TODO: Después del bloque, imprime "Stack session destroyed"
    
    // TODO: Crea una Session en el montón usando new
    //   - Nombre de usuario: "Guest", ID de sesión: 202, tamaño de registro: 3
    //   - Registra una actividad con el código 5
    //   - Imprime "Heap session activities: <count>"
    //   - Elimina la sesión
    
    // TODO: Después de eliminarla, imprime "Heap session destroyed"
    
    return 0;
}