Constructors, Destructors, and RAII

Constructors

A constructor is a special member function with the same name as the class and no return type (not even void). It is called automatically when an object is created. Its job is to put the object into a valid initial state — initializing all member variables to meaningful values.

class BankAccount {
public:
    // Constructor — same name as class, no return type
    BankAccount(const std::string& ownerName, double initialBalance)
        : owner(ownerName), balance(initialBalance)   // member initializer list
    {
        // body — runs after member init list
        if (balance < 0)
            balance = 0;  // enforce invariant
    }

    double getBalance() const { return balance; }
    const std::string& getOwner() const { return owner; }

private:
    std::string owner;
    double balance;
};

BankAccount harrys("Harry", 1500.0);  // constructor called here
std::cout << harrys.getOwner() << ": " << harrys.getBalance();

The member initializer list (after the colon, before the body) initializes members directly — more efficient than assigning in the body, and the only way to initialize const members or reference members.

The default constructor

A default constructor takes no arguments and is called when you create an object without arguments. If you define no constructors at all, the compiler generates a default constructor for you (which default-initializes or leaves trivial members uninitialized). Once you define any constructor, the compiler no longer generates the default constructor automatically — you must write it explicitly if you need both.

class Counter {
public:
    Counter() : count(0) {}          // explicit default constructor
    Counter(int start) : count(start) {}  // parameterized constructor

    void increment() { ++count; }
    int get() const { return count; }

private:
    int count;
};

Counter c1;       // calls Counter() — count = 0
Counter c2(10);   // calls Counter(int) — count = 10
Counter c3{5};    // also calls Counter(int) — brace form

C++11 allows in-class member initializers: you can provide default values directly in the class definition, which reduces constructor boilerplate:

class Counter {
public:
    Counter() = default;          // explicitly request the compiler-generated default
    Counter(int start) : count(start) {}

private:
    int count = 0;                // default member initializer — used if not set by ctor
};

Destructors

A destructoris the complement of a constructor: it runs automatically when an object's lifetime ends. Its name is a tilde followed by the class name (~ClassName()), it takes no arguments, and it returns nothing. For objects on the stack, the destructor runs when the variable goes out of scope. For heap objects, it runs when delete is called.

#include <fstream>
#include <iostream>

class LogFile {
public:
    LogFile(const std::string& path) : file(path) {
        std::cout << "LogFile opened: " << path << "\n";
    }

    ~LogFile() {
        file.close();   // automatically closes the file
        std::cout << "LogFile closed.\n";
    }

    void write(const std::string& msg) {
        file << msg << "\n";
    }

private:
    std::ofstream file;
};

void doWork() {
    LogFile log("output.txt");   // constructor runs — file opens
    log.write("Hello");
    log.write("World");
    // function ends — log goes out of scope — destructor runs — file closes
}

// No need to manually close the file!

RAII — Resource Acquisition Is Initialization

RAII is the pattern of tying a resource's lifetime to an object's lifetime. “Resource acquisition” happens in the constructor; “release” happens in the destructor. Because the destructor is guaranteed to run when the object goes out of scope — even if an exception is thrown — RAII makes resource management automatic and exception-safe.

This is why C++ programmers rarely use raw new/ delete. Instead, they use RAII wrappers:

#include <memory>

void processData()
{
    // RAII memory — no delete needed
    auto buffer = std::make_unique<int[]>(1024);

    // use buffer...
    buffer[0] = 42;

    // buffer goes out of scope here — memory freed automatically
    // even if an exception was thrown above
}

// Compare to the fragile manual approach:
void processDataManual()
{
    int* buffer = new int[1024];
    // ... use buffer ...
    // if an exception is thrown, we NEVER reach delete:
    delete[] buffer;  // memory leak if anything above throws!
}

Key rules to remember