RAII

RAII (Resource Acquisition Is Initialization) is a design principle where resource management is tied to the lifetime of an object. The idea is that resources like memory, file handles, network sockets, or locks are acquired during object initialization and released automatically when the object is destroyed.

This principle is most famously used in C++, where constructors acquire resources and destructors release them, ensuring proper cleanup even in the presence of exceptions.

Languages that support RAAI

C++ Example

#include <iostream>
#include <fstream>
 
class File {
public:
    File(const std::string& filename) {
        file.open(filename);
        if (!file.is_open()) {
            throw std::runtime_error("Could not open file");
        }
    }
    ~File() {
        if (file.is_open()) {
            file.close(); // Automatically release the resource
        }
    }
 
private:
    std::ofstream file;
};
 
int main() {
    try {
        File myFile("example.txt");
        // File is automatically closed when `myFile` goes out of scope
    } catch (const std::exception& e) {
        std::cerr << e.what() << std::endl;
    }
}

Here, the destructor ensures the file is closed when myFile goes out of scope, even if an exception occurs.

Rust Example

Rust has no destructors in the same sense as C++, but its ownership model and Drop trait implement similar functionality.

use std::fs::File;
use std::io::{self, Write};
 
fn main() -> io::Result<()> {
    let mut file = File::create("example.txt")?;
    writeln!(file, "Hello, RAII!")?;
    // File is automatically closed when it goes out of scope
    Ok(())
}

The File type in Rust implements the Drop trait, releasing resources when it goes out of scope.

Other languages

In other languages, you cannot rely on the lifecycle of an object to handle resource management, so effectively you need to take care of it manually, for example in Java or Python.

In Python, the mechanism you use is context-managers

with open("example.txt", "w") as file:
    file.write("Hello, RAII!")
# File is automatically closed when the block ends

The with statement ensures deterministic cleanup by calling the __enter__ and __exit__ methods of the context manager.

In Java instead, try-with-resource ensure that if the resource implements Autocloseable the close method is invoked even if there are exceptions

import java.io.*;
 
public class Main {
	public static void main(String[] args) {
		try (FileWriter writer = new FileWriter("example.txt")) {
			writer.write("Hello, RAII!");
		} catch (IOException e) {
			e.printStackTrace();
		}
		// Cleanup relies on the `try-with-resources` syntax in Java, not RAII
	}
}

While Java’s try-with-resources ensures cleanup, it’s not tied to object lifetime but rather to the scope of the try block.

If you don’t want to use syntactic sugar for cleanup or the language doesn’t provide explicit constructs, such as in C, you need to explicitly release the resources

#include <stdio.h>
#include <stdlib.h>
 
int main() {
    FILE *file = fopen("example.txt", "w");
    if (file == NULL) {
        return 1;
    }
    fprintf(file, "Hello, RAII!");
    fclose(file); // Must manually close the file
    return 0;
}