RAII

RAII (del inglés resource acquisition is initialization, que podría traducirse como «adquirir recursos es inicializar») es un popular patrón de diseño en varios lenguajes de programación orientados a objetos como C++ y Ada. La técnica fue inventada por Bjarne Stroustrup​ para reservar y liberar recursos en C++. En este lenguaje, después de que una excepción es lanzada, el único código fuente que con seguridad es ejecutado es el de los destructores de objetos que residen en la pila. Por lo tanto los recursos necesitan ser gestionados con objetos adecuados. Los recursos son adquiridos durante la inicialización, cuando no hay posibilidad de que sean usados antes de estar disponibles, y liberados cuando se destruyen los mismos, algo que es garantizado que suceda incluso cuando se dan errores.

La técnica RAII es vital al escribir código C++ seguro frente a excepciones: para liberar recursos antes de permitir a las excepciones que se propaguen (para evitar fugas de memoria) el desarrollador puede escribir destructores apropiados una sola vez, ahorrándose escribir código de «limpieza» duplicado y disperso por el código fuente entre bloques de manejo de excepciones que pueden ser ejecutados o no.

A diferencia de la recolección de basura, RAII tiene las ventajas de saber cuándo los objetos existen y cuándo no.

La siguiente clase RAII permite un fácil uso posterior de algunas funciones C usadas para el manejo de archivos, además quitándole al desarrollador la preocupación de: tener que ver en qué casos ha de cerrar los archivos.

#include <cstdio>
#include <stdexcept> // Para poder usar std::runtime_error

class file 
{
public:
    file (const char* filename) : file_(std::fopen(filename, "w+")) 
    {
        if (!file_) 
        {
            throw std::runtime_error("Error al abrir un archivo.");
        }
    }

    ~file() 
    {
        if (std::fclose(file_)) 
        { 
            // Nota: en general es una mala práctica lanzar excepciones desde un destructor
            throw std::runtime_error("Error al cerrar un archivo.");
        }
    }

    void write (const char* str) 
    {
        if (EOF == std::fputs(str, file_)) 
        {
            throw std::runtime_error("Error al escribir en un archivo.");
        }
    }

private:
    std::FILE* file_;

    // Evitamos la copia y asignación, ya que no están implementadas.
    file (const file &);
    file & operator= (const file &);
};

La clase file puede ser usada así:

void example_usage() 
{
    file logfile("registro_de_incidencias.txt"); // Abrimos el archivo (estamos adquiriendo un recurso).
    logfile.write("¡Hola, registro!");
    // Continuamos usando el objeto logfile.
    // Podemos lanzar excepciones, usar la orden "return", "exit", etc. sin preocuparnos de cerrar el archivo;
    // debido a que el archivo se cierra automáticamente cuando se termina la vida de logfile.
}

Se puede comparar los siguientes ejemplos en C y C++:

/* Versión en C */
#include <stdlib.h>

void f(int n)
{
    int* array = calloc(n, sizeof(int));
    realizar_otras_operaciones();
    free(array);
}

// Versión en C++.
#include <vector>

void f(int n)
{
    std::vector<int> array (n);
    realizar_otras_operaciones();
}

La versión en C requiere que el desarrollador libere la memoria en cada caso posible, a diferencia de la versión en C++.

El lenguaje de programación Python cuenta con la palabra clave with , la cual permite hacer uso de objetos que implementen los métodos __open__ y __close__. Al usar esta palabra clave, Python llamará al método __open__ del objeto. Una vez se abandona el ámbito de la sentencia with, Python llamará automáticamente al método __close__. Esto resulta muy útil, porque no sólo se llamará este método cuando finaliza el ámbito, sino que también se llamará cuando ocurra cualquier excepción. De este modo, el control de apertura y cerrado de elementos es muy sencillo. Por ejemplo, se presentan la siguiente forma de abrir un archivo:

with open("archivo.txt", "w") as archivo:
	archivo.write("Hola Mundo!")

La cual, es funcionalmente parecida a:

archivo = open("archivo.txt", "w")
archivo.write("Hola Mundo!")
archivo.close()

No obstante, si ocurriese (por algún motivo) una excepción en la ejecución del método write, el descriptor del archivo nunca sería cerrado. Por ello, para que fuera funcionalmente idéntico, sería necesario realizar la siguiente modificación:

archivo = open("archivo.txt", "w")
try:
    archivo.write("Hola Mundo!")
finally:
    archivo.close()

RAII evita la sobrecarga de los esquemas de la recolección de basura, e incluso puede ser aplicado a otros recursos como:

• Handles a archivos, que la recolección de basura mark-and-sweep no maneja con igual eficiencia.
• Ventanas que han de ser cerradas.
• Iconos en el área de notificación que han de ser ocultados.
• Código de sincronización como monitores, secciones críticas, etc. que deben ser liberados para permitir que otros hilos de ejecución (threads) los obtengan.
• Handles al registro de Microsoft Windows que estén abiertos.
• Conexiones de red.
• Objetos GDI de Windows.
• Acciones a realizar cuando se termina una función (o bloque de código) en cualquier punto posible (la acción la realiza el destructor de un objeto creado cuando empieza la función).