Classes & RAII

Struct vs class

They are the same thing with one difference: struct members default to public, class members default to private. Convention: use struct for plain data bags (like the Order and Trade in your capstone), class for types with behavior and invariants (like the OrderBook).

A class with an invariant

class Account {
public:
    // constructor: runs when an Account is created
    Account(int64_t initial) : balance_(initial) {}

    void deposit(int64_t amount) { balance_ += amount; }

    bool withdraw(int64_t amount) {
        if (amount > balance_) return false;  // invariant: never negative
        balance_ -= amount;
        return true;
    }

    int64_t balance() const { return balance_; }  // const: doesn't modify

private:
    int64_t balance_;   // hidden state; only member functions touch it
};

• Encapsulation: balance_ is private, so outside code can't set it to a bad value. The class enforces its own rules.
• Constructor: guarantees every Account starts in a valid state.
• Const member function: balance() const promises not to modify the object. Mark every non-mutating method const — the compiler enforces it and callers rely on it.

Member initializer lists

The : balance_(initial) part is the initializer list. It constructs members directly, before the constructor body runs. This is strictly better than assigning inside the body:

// GOOD: direct initialization
Widget(int x, const std::string& s) : x_(x), name_(s) {}

// WORSE: default-constructs members, then assigns — two steps, sometimes impossible
Widget(int x, const std::string& s) { x_ = x; name_ = s; }

Destructors and RAII

The destructor runs automatically when an object is destroyed. This is where RAII lives: acquire a resource in the constructor, release it in the destructor, and the object's scope guarantees cleanup.

class FileHandle {
public:
    FileHandle(const char* path) : f_(std::fopen(path, "r")) {}
    ~FileHandle() { if (f_) std::fclose(f_); }  // released automatically

    FILE* get() const { return f_; }
private:
    FILE* f_;
};

void use() {
    FileHandle fh("data.txt");
    // ... use fh.get() ...
}   // destructor runs here — file closed even if an exception is thrown

This is the pattern behind std::vector, std::string, std::unique_ptr, and std::lock_guard. Master it here and the rest of the standard library stops being mysterious.

this

Inside a member function, this is a pointer to the object the function was called on. You rarely need it explicitly, but it appears in interviews and in returning *this for chaining.