Object-Oriented Programming in C++

Procedural code — functions operating on loose data — works fine for small programs. It starts to buckle once a codebase grows past a certain size, because nothing enforces which functions are allowed to touch which data. Object-oriented programming exists to fix exactly that problem, and C++ was one of the languages that brought it to the mainstream.

Classes and Objects: The Foundation

A class is a blueprint. It defines what data (attributes) and behavior (methods) something has, without actually creating anything yet. An object is a real instance built from that blueprint.

cpp
Copy
class Car {
public:
    std::string brand;
    int speed;
 
    void accelerate() {
        speed += 10;
    }
};
 
int main() {
    Car myCar;          // an object, built from the Car class
    myCar.brand = "Toyota";
    myCar.accelerate();
}

Car is the blueprint. myCar is one specific car built from it — with its own brand and speed, independent of any other Car object you create.

The Four Pillars of OOP

1. Encapsulation

Bundling data and the methods that operate on it together, while restricting direct outside access to that data. In C++, this is done with access specifiers:

cpp
Copy
class BankAccount {
private:
    double balance;   // hidden from outside code
 
public:
    void deposit(double amount) {
        if (amount > 0) balance += amount;
    }
    double getBalance() {
        return balance;
    }
};

Nothing outside the class can touch balance directly — it can only go through deposit() and getBalance(), which means the class can enforce its own rules (like rejecting negative deposits).

2. Abstraction

Exposing only what's necessary and hiding the implementation details. When you call accelerate(), you don't need to know how the engine calculations work internally — the complexity is hidden behind a simple interface.

3. Inheritance

Letting one class reuse and extend another, instead of duplicating code.

cpp
Copy
class Vehicle {
public:
    void honk() { std::cout << "Beep!"; }
};
 
class Car : public Vehicle {
public:
    void drive() { std::cout << "Driving..."; }
};

Car automatically gets honk() from Vehicle, plus its own drive(). This models real "is-a" relationships — a car is a vehicle.

4. Polymorphism

Letting different classes respond to the same function call in their own way, usually through function overriding and virtual functions.

cpp
Copy
class Shape {
public:
    virtual double area() { return 0; }
};
 
class Circle : public Shape {
    double radius;
public:
    Circle(double r) : radius(r) {}
    double area() override { return 3.14159 * radius * radius; }
};

Calling area() on a Shape pointer that actually points to a Circle runs Circle's version — the correct behavior gets selected automatically, based on the object's real type.

Why This Actually Matters

These four principles aren't academic checkboxes — they solve concrete problems: encapsulation prevents accidental data corruption, abstraction keeps complexity manageable as code grows, inheritance eliminates duplicated logic, and polymorphism lets you write code that works across a whole family of related types without a pile of if statements checking what type something is.

The Takeaway

OOP in C++ isn't about memorizing four terms — it's a way of structuring code so that each piece owns its own data, hides what doesn't need to be exposed, and can be extended without being rewritten. Once these four ideas click together, most well-designed C++ codebases start to read as obvious rather than clever.