RAII en C++

Parte de la sección Programación Orientada a Objetos del Journey de C++ de Coddy — lección 16 de 104.

RAII (La Adquisición de Recursos es Inicialización) es un modismo fundamental de C++ donde la gestión de recursos está ligada al ciclo de vida del objeto. La idea es sencilla: adquirir recursos en el constructor, liberarlos en el destructor.

Cuando se crea un objeto, este adquiere cualquier recurso que necesite. Cuando el objeto sale de su alcance, su destructor libera automáticamente esos recursos. Esto garantiza la limpieza incluso si ocurren excepciones.

class FileHandler {
    std::FILE* file;
public:
    FileHandler(const char* filename) {
        file = std::fopen(filename, "r");  // Adquirir recurso
    }
    
    ~FileHandler() {
        if (file) std::fclose(file);       // Liberar recurso
    }
};

Con RAII, nunca olvidas realizar la limpieza:

void processFile() {
    FileHandler handler("data.txt");  // Recurso adquirido
    // Trabajar con el archivo...
    // ¡Si se lanza una excepción aquí, el destructor aún se ejecuta!
}   // Recurso liberado automáticamente

Los punteros inteligentes son el ejemplo perfecto de RAII en acción. Un unique_ptr adquiere la propiedad de la memoria heap en su constructor y la elimina en su destructor. ¡Ya has estado usando RAII sin darte cuenta!

RAII se aplica a cualquier recurso: memoria, manejadores de archivos, conexiones de red, mutexes o conexiones de bases de datos. Al envolver los recursos en objetos, C++ garantiza una limpieza determinista y elimina categorías enteras de errores como fugas y manejadores colgantes.

Desafío

Fácil

Vamos a construir un gestor de conexiones que demuestre RAII manejando automáticamente el ciclo de vida de conexiones de tipo red. Cuando se crea una conexión, debe "abrirse", y cuando sale del alcance, debe "cerrarse" automáticamente — ¡sin necesidad de limpieza manual!

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

Connection.h: Define una clase Connection que gestione un recurso de conexión utilizando los principios de RAII. La clase debe tener:
- Un atributo privado connectionId (string) para identificar la conexión
- Un atributo privado isOpen (bool) para rastrear el estado de la conexión
- Un constructor que reciba un ID de conexión, establezca isOpen en true y imprima "Opening connection: <id>"
- Un destructor que verifique si la conexión está abierta, la cierre estableciendo isOpen en false e imprima "Closing connection: <id>"
- Un método send(string message) que imprima "[<id>] Sending: <message>" si la conexión está abierta
- Un método getId() que devuelva el ID de la conexión
main.cpp: Demuestra cómo RAII asegura la limpieza automática leyendo un ID de conexión y un mensaje de la entrada. Luego:
- Crea un alcance (scope) usando llaves { }
- Dentro de ese alcance, crea un objeto Connection en la pila (stack) con el ID de entrada
- Usa la conexión para enviar el mensaje de entrada
- Deja que el alcance termine (la conexión debería cerrarse automáticamente)
- Después del alcance, imprime "Connection out of scope"

La belleza de RAII es que no necesitas recordar cerrar la conexión — el destructor se encarga de ello automáticamente cuando el objeto sale del alcance. Este patrón evita fugas de recursos incluso si sucede algo inesperado en tu código.

Incluye tu archivo de cabecera en main.cpp usando #include "Connection.h".

Hoja de referencia

RAII (Resource Acquisition Is Initialization) es un modismo de C++ donde la gestión de recursos está ligada al tiempo de vida del objeto. Los recursos se adquieren en el constructor y se liberan en el destructor.

Cuando un objeto sale de su ámbito, su destructor libera automáticamente los recursos, garantizando la limpieza incluso si ocurren excepciones:

class FileHandler {
    std::FILE* file;
public:
    FileHandler(const char* filename) {
        file = std::fopen(filename, "r");  // Adquirir recurso
    }
    
    ~FileHandler() {
        if (file) std::fclose(file);       // Liberar recurso
    }
};

RAII asegura la limpieza automática:

void processFile() {
    FileHandler handler("data.txt");  // Recurso adquirido
    // Trabajar con el archivo...
    // ¡Si se lanza una excepción, el destructor aún se ejecuta!
}   // Recurso liberado automáticamente

Los punteros inteligentes como unique_ptr son ejemplos de RAII. Adquieren memoria del montón (heap) en el constructor y la eliminan en el destructor.

RAII se aplica a cualquier recurso: memoria, manejadores de archivos, conexiones de red, mutexes o conexiones de bases de datos. Asegura una limpieza determinista y elimina errores como fugas y manejadores colgantes (dangling handles).

Pruébalo tú mismo

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

using namespace std;

int main() {
    string connectionId;
    string message;
    
    // Leer la entrada
    cin >> connectionId;
    cin.ignore();
    getline(cin, message);

    // TODO: Crear un ámbito (scope) usando llaves { }
    // Dentro del ámbito:
    //   - Crear un objeto Connection en la pila (stack) con connectionId
    //   - Usar la conexión para enviar el mensaje
    // Dejar que el ámbito termine (el destructor se llamará automáticamente)

    // TODO: Después de que termine el ámbito, imprimir "Connection out of scope"

    return 0;
}