C++ Design Patterns: Singleton, Factory, Observer, Strategy & 12 More With Modern C++17/20 (2025)

#include <iostream>
using namespace std;

// New interface clients expect
class ModernLogger {
public:
    virtual ~ModernLogger() = default;
    virtual void log(const string& msg) const = 0;
};

// Legacy system we cannot modify
class LegacyLogger {
public:
    void writeLog(const char* text) {
        cout << "[LEGACY] " << text << endl;
    }
};

// Adapter: wraps Legacy, presents ModernLogger interface
class LoggerAdapter : public ModernLogger {
    LegacyLogger legacy;
public:
    void log(const string& msg) const override {
        legacy.writeLog(msg.c_str());  // delegate + adapt
    }
};

void processApp(ModernLogger& logger) {
    logger.log("App started");
    logger.log("Processing complete");
}

int main() {
    LoggerAdapter adapter;
    processApp(adapter);  // uses legacy internally, modern interface externally
}

#include <iostream>
#include <memory>
using namespace std;

class Coffee {
public:
    virtual ~Coffee() = default;
    virtual string description() const = 0;
    virtual double cost() const noexcept = 0;
};

class Espresso : public Coffee {
public:
    string description() const override    { return "Espresso"; }
    double cost() const noexcept override  { return 1.50; }
};

// Base decorator — holds and delegates to wrapped coffee
class CoffeeDecorator : public Coffee {
protected:
    unique_ptr<Coffee> wrapped;
public:
    explicit CoffeeDecorator(unique_ptr<Coffee> c) : wrapped(move(c)) {}
};

class MilkDecorator : public CoffeeDecorator {
public:
    using CoffeeDecorator::CoffeeDecorator;
    string description() const override   { return wrapped->description() + ", Milk"; }
    double cost() const noexcept override { return wrapped->cost() + 0.30; }
};

class SugarDecorator : public CoffeeDecorator {
public:
    using CoffeeDecorator::CoffeeDecorator;
    string description() const override   { return wrapped->description() + ", Sugar"; }
    double cost() const noexcept override { return wrapped->cost() + 0.10; }
};

int main() {
    auto coffee = make_unique<Espresso>();
    coffee = make_unique<MilkDecorator>(move(coffee));
    coffee = make_unique<SugarDecorator>(move(coffee));

    cout << coffee->description() << " → $" << coffee->cost() << endl;
}

#include <iostream>
#include <vector>
#include <functional>
#include <string>
using namespace std;

class EventBus {
    using Handler = function<void(string_view)>;
    vector<Handler> handlers;

public:
    // Attach any callable: lambda, function ptr, bound method
    void on(Handler h) { handlers.push_back(move(h)); }

    void emit(string_view event) {
        for (const auto& h : handlers) h(event);
    }
};

int main() {
    EventBus bus;

    // Observers are just lambdas — no base class required
    bus.on([](string_view e){ cout << "Logger: "    << e << "\n"; });
    bus.on([](string_view e){ cout << "Analytics: " << e << "\n"; });
    bus.on([](string_view e){ cout << "Audit: "     << e << "\n"; });

    bus.emit("user.login");
    cout << "---\n";
    bus.emit("order.placed");
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;

class Sorter {
    using SortFn = function<void(vector<int>&)>;
    SortFn strategy;
public:
    explicit Sorter(SortFn fn) : strategy(move(fn)) {}
    void setStrategy(SortFn fn) { strategy = move(fn); }
    void sort(vector<int>& v) { strategy(v); }
};

// Strategies as simple lambdas or functions
auto ascending  = [](auto& v){ sort(v.begin(), v.end()); };
auto descending = [](auto& v){ sort(v.rbegin(), v.rend()); };
auto byAbsVal   = [](auto& v){ sort(v.begin(), v.end(), [](int a, int b){ return abs(a) < abs(b); }); };

int main() {
    Sorter sorter(ascending);
    vector<int> data = {3, -1, 4, -5, 2};

    sorter.sort(data);
    for (int x : data) cout << x << " ";  cout << "\n";

    sorter.setStrategy(descending);
    sorter.sort(data);
    for (int x : data) cout << x << " ";  cout << "\n";
}

#include <iostream>
#include <memory>
#include <stack>
#include <string>
using namespace std;

class Command {
public:
    virtual ~Command() = default;
    virtual void execute() = 0;
    virtual void undo()    = 0;
};

class TextEditor {
    string text;
public:
    void append(string_view s) { text += string(s); }
    void deleteChars(int n)   { if (n <= (int)text.size()) text.erase(text.size()-n); }
    void print() const        { cout << "Text: '" << text << "'\n"; }
};

class AppendCommand : public Command {
    TextEditor& editor; string added;
public:
    AppendCommand(TextEditor& e, string_view s) : editor(e), added(s) {}
    void execute() override { editor.append(added); }
    void undo()    override { editor.deleteChars(added.size()); }
};

class History {
    stack<unique_ptr<Command>> history;
public:
    void execute(unique_ptr<Command> cmd) {
        cmd->execute();
        history.push(move(cmd));
    }
    void undo() {
        if (!history.empty()) { history.top()->undo(); history.pop(); }
    }
};

int main() {
    TextEditor ed; History hist;
    hist.execute(make_unique<AppendCommand>(ed, "Hello"));
    hist.execute(make_unique<AppendCommand>(ed, ", World"));
    ed.print();   // Hello, World
    hist.undo(); ed.print(); // Hello
    hist.undo(); ed.print(); // (empty)
}

#include <iostream>
using namespace std;

// CRTP base: Derived is the template parameter
template<class Derived>
class Animal {
public:
    // Non-virtual: dispatches at compile time via static_cast
    void makeSound() {
        static_cast<Derived*>(this)->sound();  // resolved at compile time
    }

    // Mixin: automatically available to all Animals
    void describe() {
        cout << "I am a " << static_cast<Derived*>(this)->name() << "\n";
        makeSound();
    }
};

class Dog : public Animal<Dog> {
public:
    void   sound() { cout << "Woof!\n"; }
    string name()  { return "Dog"; }
};

class Cat : public Animal<Cat> {
public:
    void   sound() { cout << "Meow!\n"; }
    string name()  { return "Cat"; }
};

// Template function — static dispatch, no virtual table
template<class T>
void greet(Animal<T>& a) { a.describe(); }

int main() {
    Dog d; greet(d);
    Cat c; greet(c);
    // Zero vtable overhead — equivalent to direct function calls
}

// ── widget.h (public API — only forward declaration) ────────────
#pragma once
#include <memory>
#include <string>

class Widget {
public:
    Widget(const std::string& name);
    ~Widget();                     // defined in .cpp where Impl is complete
    Widget(Widget&&) noexcept;
    Widget& operator=(Widget&&) noexcept;

    void render() const;

private:
    struct Impl;                   // forward declaration only
    std::unique_ptr<Impl> pImpl;  // pointer — sizeof(Widget) never changes
};

// ── widget.cpp (implementation — hidden from header users) ───────
#include "widget.h"
#include <iostream>

struct Widget::Impl {
    std::string name;
    int renderCount = 0;
    // Adding members here does NOT require recompiling widget.h users
};

Widget::Widget(const std::string& n) : pImpl(std::make_unique<Impl>()) {
    pImpl->name = n;
}
Widget::~Widget() = default;
Widget::Widget(Widget&&) noexcept = default;
Widget& Widget::operator=(Widget&&) noexcept = default;

void Widget::render() const {
    cout << "Rendering " << pImpl->name
         << " (count=" << ++pImpl->renderCount << ")\n";
}