Object-Oriented Programming

#include <iostream>
using namespace std;

// ─── ENCAPSULATION: private data + public methods ───
class BankAccount {
private:
    double balance;          // hidden from outside

public:
    BankAccount() : balance(0) {}

    void deposit(double amount) {
        if (amount > 0) balance += amount;
    }

    double getBalance() { return balance; }
};

// ─── ABSTRACTION: hide complexity ───
class Shape {
public:
    virtual double area() = 0;   // pure virtual = what, not how
    virtual ~Shape() {}
};

// ─── INHERITANCE + POLYMORPHISM ───
class Circle : public Shape {
    double radius;
public:
    Circle(double r) : radius(r) {}

    // Overriding — same method, different behavior
    double area() override {
        return 3.14159 * radius * radius;
    }
};

class Rectangle : public Shape {
    double w, h;
public:
    Rectangle(double w, double h) : w(w), h(h) {}

    double area() override { return w * h; }
};

class Calculator {
public:
    // Same name, different parameters → resolved at compile time
    int    add(int a, int b)           { return a + b; }
    double add(double a, double b)    { return a + b; }
    int    add(int a, int b, int c)  { return a + b + c; }
};

// Compiler picks which add() to call based on argument types

class Animal {
public:
    virtual void speak() {
        cout << "Some sound" << endl;
    }
    virtual ~Animal() {}
};

class Dog : public Animal {
public:
    void speak() override {
        cout << "Bark!" << endl;
    }
};

class Cat : public Animal {
public:
    void speak() override {
        cout << "Meow!" << endl;
    }
};

// Decided at RUNTIME based on actual object type
Animal* animal = new Dog();
animal->speak();   // Output: "Bark!" (not "Some sound")
delete animal;

// ─── ABSTRACT CLASS (has some implementation) ───
class Animal {
protected:
    string name;
public:
    Animal(string n) : name(n) {}

    void sleep() { cout << name << " is sleeping" << endl; }

    virtual void makeSound() = 0;   // pure virtual
    virtual ~Animal() {}
};

// ─── INTERFACE (all pure virtual, no data) ───
class Flyable {
public:
    virtual void fly() = 0;
    virtual ~Flyable() {}
};

class Swimmable {
public:
    virtual void swim() = 0;
    virtual ~Swimmable() {}
};

// Duck: IS-A Animal, CAN fly, CAN swim
class Duck : public Animal, public Flyable, public Swimmable {
public:
    Duck() : Animal("Duck") {}

    void makeSound() override { cout << "Quack!" << endl; }
    void fly()       override { cout << "Flying..." << endl; }
    void swim()      override { cout << "Swimming..." << endl; }
};

// ─── AGGREGATION: Employee exists independently ───
class Employee { /* ... */ };

class Department {
    vector<Employee*> employees;   // pointers → don't own
public:
    void addEmployee(Employee* e) {
        employees.push_back(e);    // passed from outside
    }
    // ~Department does NOT delete employees
};

// ─── COMPOSITION: Room dies with House ───
class Room {
public:
    string name;
    Room(string n) : name(n) {}
};

class House {
    vector<Room> rooms;             // owns by value
public:
    House() {
        rooms.push_back(Room("Bedroom"));   // created inside
        rooms.push_back(Room("Kitchen"));
    }
    // ~House destroys all Rooms automatically
};

class Employee {
    string name;
    int age;
    string department;

public:
    // Full constructor
    Employee(string n, int a, string d)
        : name(n), age(a), department(d) {}

    // Delegating constructor → calls full constructor
    Employee(string n, int a)
        : Employee(n, a, "General") {}    // C++11

    // Another delegation
    Employee(string n)
        : Employee(n, 0, "General") {}
};

// Child → Parent via initializer list
class Manager : public Employee {
    int teamSize;
public:
    Manager(string n, int a, int ts)
        : Employee(n, a, "Management"),  // call parent
          teamSize(ts) {}
};

class Person {
    char* name;
    int age;

public:
    Person(const char* n, int a) : age(a) {
        name = new char[strlen(n) + 1];
        strcpy(name, n);
    }

    // ─── SHALLOW COPY (default) — DANGEROUS ───
    // Default copy constructor just copies pointer value
    // Both objects point to SAME memory → double free crash!

    // ─── DEEP COPY — SAFE ───
    Person(const Person& other) : age(other.age) {
        name = new char[strlen(other.name) + 1];
        strcpy(name, other.name);   // allocate + copy
    }

    ~Person() { delete[] name; }
};

Person a("John", 25);
Person b = a;   // calls deep copy constructor
// a and b have independent memory — safe!

class Employee {
    string name;                      // instance — per object
    static int totalCount;            // static — shared by all

public:
    Employee(string n) : name(n) {
        totalCount++;                 // increment shared counter
    }

    static int getTotal() {
        // can't use 'name' here — no 'this' pointer
        return totalCount;
    }
};

int Employee::totalCount = 0;  // define outside class

Employee e1("John");
Employee e2("Jane");
cout << Employee::getTotal();   // 2

class A {
public:
    void show() { cout << "A"; }
};

// virtual inheritance → only ONE copy of A in D
class B : virtual public A { };
class C : virtual public A { };
class D : public B, public C { };

D d;
d.show();     // No ambiguity! Only one A::show()

class OrderService {
    MySQLDatabase db;   // hardcoded dependency!
public:
    OrderService() : db() {}
    // Can't test without real MySQL.
    // Can't switch to PostgreSQL.
};

// Abstraction (interface)
class IDatabase {
public:
    virtual void save(const Order& order) = 0;
    virtual ~IDatabase() {}
};

class OrderService {
    IDatabase& db;   // depends on abstraction
public:
    // CONSTRUCTOR INJECTION
    OrderService(IDatabase& database) : db(database) {}

    void placeOrder(const Order& order) {
        db.save(order);
    }
};

// Usage — inject any implementation
MySQLDatabase mysql;
OrderService service(mysql);

// For testing — inject mock
MockDatabase mock;
OrderService testService(mock);

class ImmutablePoint {
    const int x;
    const int y;

public:
    ImmutablePoint(int x, int y) : x(x), y(y) {}

    // Only getters, no setters
    int getX() const { return x; }
    int getY() const { return y; }

    // "Modification" returns new object
    ImmutablePoint move(int dx, int dy) const {
        return ImmutablePoint(x + dx, y + dy);
    }
};

ImmutablePoint p1(3, 4);
ImmutablePoint p2 = p1.move(1, 2);   // p1 unchanged, p2 is (4,6)

class Logger {
private:
    Logger() {}                            // private constructor
    Logger(const Logger&) = delete;        // no copy
    Logger& operator=(const Logger&) = delete;

public:
    static Logger& getInstance() {
        static Logger instance;  // thread-safe in C++11
        return instance;
    }

    void log(const string& msg) {
        cout << "[LOG] " << msg << endl;
    }
};

// Usage
Logger::getInstance().log("Server started");

class Shape {
public:
    virtual void draw() = 0;
    virtual ~Shape() {}
};

class Circle : public Shape {
public:
    void draw() override { cout << "Drawing Circle" << endl; }
};

class Rectangle : public Shape {
public:
    void draw() override { cout << "Drawing Rect" << endl; }
};

// Factory
class ShapeFactory {
public:
    static unique_ptr<Shape> create(const string& type) {
        if (type == "circle")    return make_unique<Circle>();
        if (type == "rectangle") return make_unique<Rectangle>();
        return nullptr;
    }
};

// Client doesn't know about Circle/Rectangle
auto shape = ShapeFactory::create("circle");
shape->draw();

// Strategy interface
class PaymentStrategy {
public:
    virtual void pay(int amount) = 0;
    virtual ~PaymentStrategy() {}
};

class CreditCard : public PaymentStrategy {
public:
    void pay(int amount) override {
        cout << "Paid $" << amount << " via Credit Card" << endl;
    }
};

class PayPal : public PaymentStrategy {
public:
    void pay(int amount) override {
        cout << "Paid $" << amount << " via PayPal" << endl;
    }
};

// Context
class ShoppingCart {
    unique_ptr<PaymentStrategy> strategy;
public:
    void setStrategy(unique_ptr<PaymentStrategy> s) {
        strategy = move(s);
    }
    void checkout(int amount) {
        strategy->pay(amount);   // delegates to strategy
    }
};

// Switch strategies at runtime
ShoppingCart cart;
cart.setStrategy(make_unique<CreditCard>());
cart.checkout(100);
cart.setStrategy(make_unique<PayPal>());
cart.checkout(50);