RAII como patrón

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

RAII (Resource Acquisition Is Initialization) es más que un simple modismo de C++: es un potente patrón de diseño que vincula la gestión de recursos con el ciclo de vida de los objetos. Ya has visto RAII con punteros inteligentes, pero el patrón se aplica a cualquier recurso: identificadores de archivos, conexiones de red, mutexes o transacciones de bases de datos.

La idea central es sencilla: adquiere los recursos en el constructor y libéralos en el destructor. Como C++ garantiza que los destructores se ejecuten cuando los objetos salen del ámbito, la limpieza se realiza automáticamente, incluso cuando se producen excepciones:

#include <iostream>
#include <fstream>

class FileGuard {
    std::ofstream file;
public:
    FileGuard(const std::string& filename) : file(filename) {
        if (!file.is_open()) {
            std::cout << "Failed to open file\n";
        }
    }
    
    void write(const std::string& text) {
        if (file.is_open()) file << text;
    }
    
    ~FileGuard() {
        if (file.is_open()) {
            file.close();
            std::cout << "File closed automatically\n";
        }
    }
};

int main() {
    {
        FileGuard guard("output.txt");
        guard.write("Hello RAII");
    }  // Destructor llamado aquí - archivo cerrado
    
    std::cout << "After scope\n";
}

RAII destaca al gestionar bloqueos en código multihilo. std::lock_guard de la biblioteca estándar sigue este patrón: adquiere un mutex durante la construcción y lo libera durante la destrucción, evitando interbloqueos causados por olvidarse de desbloquear.

Al implementar clases RAII, recuerda eliminar o implementar correctamente las operaciones de copia/movimiento (Regla de Cinco) para evitar la duplicación de recursos o problemas de doble liberación. RAII transforma la gestión manual de recursos propensa a errores en una limpieza segura y automática.

Desafío

Fácil

Construyamos un Administrador de grupos de conexiones usando RAII para gestionar de forma segura las conexiones a la base de datos. En las aplicaciones reales, las conexiones a la base de datos son recursos costosos que deben adquirirse y liberarse correctamente. Crearás un envoltorio RAII que garantiza que las conexiones siempre se devuelvan al grupo, incluso si se producen excepciones o las rutas del código se vuelven complicadas.

Organizarás tu código en tres archivos:

ConnectionPool.h: Crea un grupo de conexiones sencillo que gestione un número limitado de conexiones.
Tu clase ConnectionPool debe llevar el control de cuántas conexiones están disponibles (comenzando con una capacidad pasada al constructor). Implementa:
- acquire(): si hay una conexión disponible, disminuye el contador e imprime Connection acquired (X available), donde X es el contador restante; devuelve true si tiene éxito y false si no hay conexiones disponibles
- release(): aumenta el contador de conexiones disponibles e imprime Connection released (X available)
- available(): devuelve el número actual de conexiones disponibles
ConnectionGuard.h: Construye el envoltorio RAII que gestione de forma segura una sola conexión.
Tu clase ConnectionGuard representa el patrón RAII. Debe:
- Recibir una referencia a un ConnectionPool en su constructor e intentar adquirir una conexión
- Almacenar si la adquisición tuvo éxito
- Proporcionar un método isConnected() para comprobar si el guardián contiene una conexión válida
- Liberar automáticamente la conexión de vuelta al grupo en el destructor (solo si se adquirió una)
- Eliminar el constructor de copia y la asignación de copia para evitar la duplicación de recursos (consideración de la Regla de Cinco)
Cuando se ejecute el destructor, si había una conexión retenida, imprime Guard releasing connection antes de llamar a release en el grupo.
main.cpp: Demuestra la limpieza automática de RAII mediante ámbitos.
Lee dos entradas:
1. Capacidad del grupo (entero)
2. Número de conexiones que solicitar (entero)
Crea un ConnectionPool con la capacidad indicada. Después, dentro de un ámbito anidado (usando llaves), crea el número solicitado de objetos ConnectionGuard almacenados en un vector. Para cada guardián, imprime si se conectó correctamente:
- Si se conectó: Guard N: Connected
- Si no se conectó: Guard N: Failed to connect
(donde N comienza en 1)

Cuando termina el ámbito (se destruyen los guardianes), imprime After scope: X connections available, mostrando el estado final del grupo.

Por ejemplo, con las entradas 2 y 3:

Connection acquired (1 available)
Guard 1: Connected
Connection acquired (0 available)
Guard 2: Connected
Guard 3: Failed to connect
Guard releasing connection
Connection released (1 available)
Guard releasing connection
Connection released (2 available)
After scope: 2 connections available

Con las entradas 3 y 2:

Connection acquired (2 available)
Guard 1: Connected
Connection acquired (1 available)
Guard 2: Connected
Guard releasing connection
Connection released (2 available)
Guard releasing connection
Connection released (3 available)
After scope: 3 connections available

Observa cómo las conexiones se liberan automáticamente cuando los guardianes salen de su ámbito. Nunca llamas explícitamente a release en tu código principal. Los destructores se ejecutan en orden inverso al de construcción (el último guardián se destruye primero), y se garantiza que cada conexión adquirida se devuelva. Este es el poder de RAII: la limpieza de recursos ocurre de forma automática y fiable, sin importar cómo termine el ámbito.

Pruébalo tú mismo

#include <iostream>
#include <vector>
#include "ConnectionPool.h"
#include "ConnectionGuard.h"

using namespace std;

int main() {
    // Lee las entradas
    int capacity;
    int numConnections;
    cin >> capacity;
    cin >> numConnections;
    
    // TODO: Crea un ConnectionPool con la capacidad dada
    
    // TODO: Crea un ámbito anidado usando llaves
    {
        // TODO: Crea un vector para almacenar objetos ConnectionGuard
        // Pista: Necesitarás usar punteros o punteros inteligentes ya que ConnectionGuard
        // tiene el constructor de copia eliminado
        
        // TODO: Bucle para crear numConnections guards
        // Para cada guard, imprime ya sea:
        // "Guard N: Connected" or "Guard N: Failed to connect"
        // donde N empieza en 1
        
    }
    // Los guards se destruyen aquí cuando el ámbito termina
    
    // TODO: Print "After scope: X connections available"
    
    return 0;
}