Posted on Oct 8

RAII Explained: Why C++ Doesn't Need a Garbage Collector

RAII is a core C++ philosophy you can't skip. It ties resources; files, memory, locks, directly to object lifetimes and scope.

Think of it as a localized garbage collector(gc) under your control.

It's a blueprint that tells the compiler to insert cleanup code at crucial spots; like defer in Zig or Go, that runs at the end of a scope.

By "blueprint" I mean, a way of structuring code(the rule of 5 below) so the compiler automatically generates cleanup tied to scope.

The Rule of Five

Here's the classic RAII skeleton:

class ResourceHolder { public: ResourceHolder(); // Constructor ~ResourceHolder(); // Destructor ResourceHolder(const ResourceHolder&); // Copy constructor ResourceHolder& operator=(const ResourceHolder&); // Copy assignment ResourceHolder(ResourceHolder&&) noexcept; // Move constructor ResourceHolder& operator=(ResourceHolder&&) noexcept; // Move assignment };

Want to ban copying? Delete it:

ResourceHolder(const ResourceHolder&) = delete; ResourceHolder& operator=(const ResourceHolder&) = delete;

Once you grasp self-regulating objects, you learn to lean on smart pointers for ownership:

std::unique_ptr<ResourceHolder> a; a = std::make_unique<ResourceHolder>(); // one owner at a time std::shared_ptr<ResourceHolder> b; // multiple owners allowed

Smart pointers track ownership automatically, once no one owns an object, it cleans itself up(like a localized gc).

The RAII Template With Examples

For RAII, the bare minimum is:

a constructor (acquire the resource),
a destructor (release the resource).

Copy/move can be defaulted or customized depending on your needs.

Example: managing a file safely.

class File { std::fstream file; public: File(const std::string& filename, std::ios::openmode mode) : file(filename, mode) { if (!file.is_open()) { throw std::runtime_error("Failed to open file: " + filename); } } ~File() { if (file.is_open()) { file.close(); } } // Prevent copying File(const File&) = delete; File& operator=(const File&) = delete; // Allow moving File(File&& other) noexcept : file(std::move(other.file)) {} File& operator=(File&& other) noexcept { if (this != &other) { file = std::move(other.file); } return *this; } };

Standard Library RAII

RAII is also baked into the standard template library(STL).

void simple_example() { std::vector<int> numbers; // acquire memory numbers.push_back(42); // use resource // cleanup happens automatically when numbers goes out of scope }

Even better: RAII plays nicely with exceptions.

void safe_function() { std::ifstream file("data.txt"); std::vector<int> buffer(1024); // Resources freed automatically, // even if we return early or throw. }

RAII in Structs

C++ doesn’t care if you use struct or class, the only difference is default visibility (public for structs vs private). Both can do RAII.

struct FileHandler { std::unique_ptr<std::fstream> file; FileHandler(const std::string& filename) { file = std::make_unique<std::fstream>(filename, std::ios::in | std::ios::out); if (!file->is_open()) { throw std::runtime_error("Failed to open file"); } } ~FileHandler() { if (file && file->is_open()) { file->close(); } } FileHandler(const FileHandler&) = delete; FileHandler& operator=(const FileHandler&) = delete; FileHandler(FileHandler&&) = default; FileHandler& operator=(FileHandler&&) = default; void write(const std::string& content) { if (file) *file << content; } };