C++

Constructors, Destructors & RAII

Classes & Objects introduced the constructor briefly, as the method that runs automatically on creation. This chapter is the full picture: what runs at the other end of an object's life too, and the single idiom — RAII — that both enable, which quietly eliminates an entire category of bug that's constant, manual work in C.

Constructors, in more depth

class Buffer {
public:
    Buffer(int size) {           // constructor — takes arguments like any function
        data = new int[size];     // allocate on construction
        capacity = size;
        std::cout << "Buffer created\n";
    }

private:
    int *data;
    int capacity;
};

Buffer b(100);   // constructor runs immediately — data is allocated before the next line runs

A constructor can take parameters exactly like any function, letting an object configure itself at creation time instead of needing a separate, easy-to-forget "init" call — a pattern C code has to write by hand every time.

Destructors

class Buffer {
public:
    Buffer(int size) {
        data = new int[size];
        std::cout << "Buffer created\n";
    }

    ~Buffer() {                    // destructor — same name as the class, prefixed with ~
        delete[] data;              // free exactly what the constructor allocated
        std::cout << "Buffer destroyed\n";
    }

private:
    int *data;
};

void useBuffer() {
    Buffer b(100);
    // ... use b ...
}   // b goes out of scope HERE — ~Buffer() runs automatically, data is freed

The destructor runs the instant an object's scope ends — no explicit call needed, and no way to accidentally skip it on a normal exit path. This is the direct C++ answer to the exact Dynamic Memory problem of a forgotten free(): pair every resource's acquisition with a matching release, in one place, guaranteed to run.

RAII — the idiom both enable

RAII (Resource Acquisition Is Initialization) is the practice of acquiring a resource in a constructor and releasing it in the matching destructor — tying the resource's lifetime directly to an object's lifetime, which C++ already guarantees is well-defined and automatic:

class FileHandle {
public:
    FileHandle(const char *path) {
        file = fopen(path, "r");   // ACQUIRE in the constructor
    }
    ~FileHandle() {
        if (file) fclose(file);     // RELEASE in the destructor — always runs
    }
    FILE *get() { return file; }

private:
    FILE *file;
};

void readConfig() {
    FileHandle f("config.txt");   // file opened
    // ... use f.get() ...
    // even if an exception is thrown here, ~FileHandle() STILL runs
}   // file closed automatically, guaranteed, right here

Compare this to the equivalent C file-handling code, where every single exit path — including an early return on an error — has to remember its own matching fclose. RAII makes "forgetting to clean up" a non-issue by construction, not a discipline problem.

An object's full lifecycle

Real-world applications

• Smart pointers — std::unique_ptr and std::shared_ptr (covered fully in the upcoming Memory Management chapter) are RAII applied to raw memory itself.
• Lock guards — a mutex lock acquired in a constructor and released in a destructor guarantees the lock is released even if an exception unwinds through the function — a real, common concurrency-safety pattern.
• Hardware peripheral wrappers — a class that enables a peripheral in its constructor and disables it in its destructor, ensuring a peripheral is never left powered on by a forgotten cleanup call.

Gotchas