SOLID Principles — C++ Examples, Violations, and Interview Self-Check

// SOLID Principles — C++ examples

// S — Single Responsibility: one class, one reason to change
// BAD: one class handles data + formatting + sending
class Report {
    void generate() { /* query data */ }
    void toHTML() { /* format */ }
    void sendEmail() { /* smtp */ }
};
// GOOD: split by responsibility
class ReportGenerator {
    void generate();
};
class ReportFormatter {
    void toHTML();
};
class ReportMailer {
    void send();
};

// O — Open/Closed: open for extension, closed for modification
// BAD: switch on type — must edit when new type added
double area(Shape s) {
    if (s.type == CIRCLE)
        ... if (s.type == RECT)...
}

// GOOD: extend by adding new class
struct Shape {
    virtual double area() const = 0;
};
struct Circle : Shape {
    double area() const override {
        return pi * r * r;
    }
};
struct Rect : Shape {
    double area() const override {
        return w * h;
    }
};

// L — Liskov Substitution: derived must safely replace base
// BAD: Ostrich can't fly — violates Bird contract
struct Bird {
    virtual void fly() {}
};
struct Ostrich : Bird {
    void fly() override {
        throw;
    }
}; // VIOLATION

// GOOD: separate interface
struct Animal {
    virtual void move() {}
};
struct FlyingBird : Animal {
    virtual void fly() {}
};
struct Ostrich2 : Animal {
    void move() override {}
}; // only move, no fly

// I — Interface Segregation: don't force unused methods
// BAD: every device must implement scan AND print AND fax
struct Machine {
    virtual void print() = 0;
    virtual void scan() = 0;
    virtual void fax() = 0;
};

// GOOD: split interfaces
struct Printer {
    virtual void print() = 0;
};
struct Scanner {
    virtual void scan() = 0;
};
struct SimplePrinter : Printer {
    void print() override {}
}; // only what it needs

// D — Dependency Inversion: depend on abstractions, not concretes
// BAD: high-level tied to concrete
class OrderService {
    MySQLDB db;
    void saveOrder(Order o) {
        db.insert(o);
    }
};

// GOOD: depend on interface
struct IDatabase {
    virtual void insert(Order) = 0;
};
class OrderService2 {
    IDatabase& db_;
    OrderService2(IDatabase& db) : db_(db) {} // inject via ctor
    void saveOrder(Order o) {
        db_.insert(o);
    }
};
// Now: swap MySQLDB → MockDB → RedisDB without touching OrderService2