C++ Design Patterns

Structural patterns deal with how classes and objects are composed to form larger structures. They help ensure that when one part of a system changes, the entire structure doesn't need to change.

The Adapter Pattern

The Adapter pattern allows incompatible interfaces to work together. Think of it like a power plug adapter when traveling - your laptop has one type of plug, but the wall outlet is different. The adapter sits in between and makes them compatible.

In software, you often need to use a class that has a different interface than what your code expects. Maybe you're integrating a third-party library, or working with legacy code. Instead of modifying the existing class (which might not be possible), you create an adapter that translates between interfaces.

#include <iostream>
#include <string>

// Legacy interface that we can't modify
class OldPrinter {
public:
    void printOldWay(const std::string& text) {
        std::cout << "*** OLD PRINTER ***" << std::endl;
        std::cout << text << std::endl;
        std::cout << "******************" << std::endl;
    }
};

// New interface that our system expects
class Printer {
public:
    virtual ~Printer() = default;
    virtual void print(const std::string& document) = 0;
};

// Adapter - makes OldPrinter compatible with Printer interface
class PrinterAdapter : public Printer {
public:
    PrinterAdapter(OldPrinter& oldPrinter) : oldPrinter_(oldPrinter) {}
    
    void print(const std::string& document) override {
        // Translate the call to the old interface
        oldPrinter_.printOldWay(document);
    }
    
private:
    OldPrinter& oldPrinter_;
};

// Client code that expects the new Printer interface
void printDocument(Printer& printer, const std::string& doc) {
    printer.print(doc);
}

int main() {
    OldPrinter legacyPrinter;
    PrinterAdapter adapter(legacyPrinter);
    
    // Now we can use the old printer through the new interface
    printDocument(adapter, "Hello, Adapter Pattern!");
    
    return 0;
}

The Decorator Pattern

The Decorator pattern lets you add new behaviors to objects dynamically by wrapping them in decorator objects. Think of it like adding toppings to a pizza - you start with a base pizza and can add cheese, pepperoni, mushrooms, etc. Each topping "decorates" the pizza with extra features.

This pattern follows the Open/Closed Principle - you can extend behavior without modifying existing code. Instead of creating a subclass for every combination of features, you compose decorators at runtime.

#include <iostream>
#include <string>
#include <memory>

// Component interface
class Coffee {
public:
    virtual ~Coffee() = default;
    virtual std::string getDescription() const = 0;
    virtual double getCost() const = 0;
};

// Concrete component - base coffee
class SimpleCoffee : public Coffee {
public:
    std::string getDescription() const override {
        return "Simple Coffee";
    }
    
    double getCost() const override {
        return 2.00;
    }
};

// Base decorator - also implements Coffee interface
class CoffeeDecorator : public Coffee {
public:
    explicit CoffeeDecorator(std::unique_ptr<Coffee> coffee) 
        : coffee_(std::move(coffee)) {}
    
    std::string getDescription() const override {
        return coffee_->getDescription();
    }
    
    double getCost() const override {
        return coffee_->getCost();
    }
    
protected:
    std::unique_ptr<Coffee> coffee_;
};

// Concrete decorators - add extras
class MilkDecorator : public CoffeeDecorator {
public:
    explicit MilkDecorator(std::unique_ptr<Coffee> coffee) 
        : CoffeeDecorator(std::move(coffee)) {}
    
    std::string getDescription() const override {
        return coffee_->getDescription() + ", Milk";
    }
    
    double getCost() const override {
        return coffee_->getCost() + 0.50;
    }
};

class SugarDecorator : public CoffeeDecorator {
public:
    explicit SugarDecorator(std::unique_ptr<Coffee> coffee) 
        : CoffeeDecorator(std::move(coffee)) {}
    
    std::string getDescription() const override {
        return coffee_->getDescription() + ", Sugar";
    }
    
    double getCost() const override {
        return coffee_->getCost() + 0.25;
    }
};

class WhippedCreamDecorator : public CoffeeDecorator {
public:
    explicit WhippedCreamDecorator(std::unique_ptr<Coffee> coffee) 
        : CoffeeDecorator(std::move(coffee)) {}
    
    std::string getDescription() const override {
        return coffee_->getDescription() + ", Whipped Cream";
    }
    
    double getCost() const override {
        return coffee_->getCost() + 0.75;
    }
};

int main() {
    // Start with simple coffee
    std::unique_ptr<Coffee> myCoffee = std::make_unique<SimpleCoffee>();
    std::cout << myCoffee->getDescription() << " - $" 
              << myCoffee->getCost() << std::endl;
    
    // Add milk
    myCoffee = std::make_unique<MilkDecorator>(std::move(myCoffee));
    std::cout << myCoffee->getDescription() << " - $" 
              << myCoffee->getCost() << std::endl;
    
    // Add sugar
    myCoffee = std::make_unique<SugarDecorator>(std::move(myCoffee));
    std::cout << myCoffee->getDescription() << " - $" 
              << myCoffee->getCost() << std::endl;
    
    // Add whipped cream
    myCoffee = std::make_unique<WhippedCreamDecorator>(std::move(myCoffee));
    std::cout << myCoffee->getDescription() << " - $" 
              << myCoffee->getCost() << std::endl;
    
    return 0;
}
// Output:
// Simple Coffee - $2
// Simple Coffee, Milk - $2.5
// Simple Coffee, Milk, Sugar - $2.75
// Simple Coffee, Milk, Sugar, Whipped Cream - $3.5

The Facade Pattern

The Facade pattern provides a simplified interface to a complex subsystem. Think of it like using a TV remote - you don't need to understand the complex electronics inside, you just press "power" and "volume up." The remote is a facade that hides the complexity.

Facades are useful when you have a complex system with many classes and you want to provide a simple, easy-to-use interface for common tasks. The client doesn't need to know about all the subsystem classes - they just interact with the facade.

#include <iostream>
#include <string>

// Complex subsystem classes
class CPU {
public:
    void freeze() { std::cout << "CPU: Freezing..." << std::endl; }
    void jump(long address) { 
        std::cout << "CPU: Jumping to " << address << std::endl; 
    }
    void execute() { std::cout << "CPU: Executing..." << std::endl; }
};

class Memory {
public:
    void load(long address, const std::string& data) {
        std::cout << "Memory: Loading '" << data 
                  << "' at " << address << std::endl;
    }
};

class HardDrive {
public:
    std::string read(long sector, int size) {
        std::cout << "HardDrive: Reading sector " << sector << std::endl;
        return "boot_data";
    }
};

// Facade - provides simple interface to complex subsystem
class ComputerFacade {
public:
    ComputerFacade() : cpu_(), memory_(), hardDrive_() {}
    
    void start() {
        std::cout << "=== Starting Computer ===" << std::endl;
        cpu_.freeze();
        std::string bootData = hardDrive_.read(0, 1024);
        memory_.load(0, bootData);
        cpu_.jump(0);
        cpu_.execute();
        std::cout << "=== Computer Started ===" << std::endl;
    }
    
    void shutdown() {
        std::cout << "=== Shutting Down ===" << std::endl;
        // Cleanup operations...
    }
    
private:
    CPU cpu_;
    Memory memory_;
    HardDrive hardDrive_;
};

class CelsiusThermometer {
public:
    double getTemperatureC() { return 25.0; }
};

class Thermometer {
public:
    virtual ~Thermometer() = default;
    virtual double getTemperatureF() = 0;
};

class ThermometerAdapter : public Thermometer {
public:
    ThermometerAdapter(CelsiusThermometer& t) : celsius_(t) {}
    
    double getTemperatureF() override {
        return celsius_.getTemperatureC() * 9.0 / 5.0 + 32.0;
    }
    
private:
    CelsiusThermometer& celsius_;
};

int main() {
    CelsiusThermometer oldThermo;
    ThermometerAdapter adapter(oldThermo);
    
    std::cout << adapter.getTemperatureF() << "°F" << std::endl;  // 77°F
}

#include <iostream>
#include <memory>

class Pizza {
public:
    virtual ~Pizza() = default;
    virtual std::string getDescription() const = 0;
    virtual double getPrice() const = 0;
};

class PlainPizza : public Pizza {
public:
    std::string getDescription() const override { return "Plain Pizza"; }
    double getPrice() const override { return 8.00; }
};

class ToppingDecorator : public Pizza {
public:
    ToppingDecorator(std::unique_ptr<Pizza> p) : pizza_(std::move(p)) {}
protected:
    std::unique_ptr<Pizza> pizza_;
};

class CheeseDecorator : public ToppingDecorator {
public:
    using ToppingDecorator::ToppingDecorator;
    std::string getDescription() const override {
        return pizza_->getDescription() + ", Extra Cheese";
    }
    double getPrice() const override { return pizza_->getPrice() + 1.50; }
};

class PepperoniDecorator : public ToppingDecorator {
public:
    using ToppingDecorator::ToppingDecorator;
    std::string getDescription() const override {
        return pizza_->getDescription() + ", Pepperoni";
    }
    double getPrice() const override { return pizza_->getPrice() + 2.00; }
};

int main() {
    std::unique_ptr<Pizza> pizza = std::make_unique<PlainPizza>();
    pizza = std::make_unique<CheeseDecorator>(std::move(pizza));
    pizza = std::make_unique<PepperoniDecorator>(std::move(pizza));
    
    std::cout << pizza->getDescription() << std::endl;
    std::cout << "$" << pizza->getPrice() << std::endl;
    // Plain Pizza, Extra Cheese, Pepperoni - $11.50
}

#include <iostream>
#include <string>

class TV {
public:
    void on() { std::cout << "TV: Turning on" << std::endl; }
    void off() { std::cout << "TV: Turning off" << std::endl; }
    void setInput(const std::string& input) {
        std::cout << "TV: Setting input to " << input << std::endl;
    }
};

class SoundSystem {
public:
    void on() { std::cout << "Sound: Powering on" << std::endl; }
    void off() { std::cout << "Sound: Powering off" << std::endl; }
    void setVolume(int level) {
        std::cout << "Sound: Volume set to " << level << std::endl;
    }
    void setSurroundMode() {
        std::cout << "Sound: Surround mode enabled" << std::endl;
    }
};

class StreamingPlayer {
public:
    void on() { std::cout << "Player: Starting up" << std::endl; }
    void off() { std::cout << "Player: Shutting down" << std::endl; }
    void play(const std::string& movie) {
        std::cout << "Player: Playing '" << movie << "'" << std::endl;
    }
    void stop() { std::cout << "Player: Stopped" << std::endl; }
};

class Lights {
public:
    void dim(int level) {
        std::cout << "Lights: Dimming to " << level << "%" << std::endl;
    }
    void on() { std::cout << "Lights: Full brightness" << std::endl; }
};

class HomeTheaterFacade {
public:
    void watchMovie(const std::string& movie) {
        std::cout << "=== Getting ready to watch " << movie << " ===" << std::endl;
        lights_.dim(10);
        tv_.on();
        tv_.setInput("HDMI1");
        sound_.on();
        sound_.setVolume(25);
        sound_.setSurroundMode();
        player_.on();
        player_.play(movie);
        std::cout << "=== Movie started! Enjoy! ===" << std::endl;
    }
    
    void endMovie() {
        std::cout << "=== Shutting down theater ===" << std::endl;
        player_.stop();
        player_.off();
        sound_.off();
        tv_.off();
        lights_.on();
        std::cout << "=== Theater shut down ===" << std::endl;
    }
    
private:
    TV tv_;
    SoundSystem sound_;
    StreamingPlayer player_;
    Lights lights_;
};

int main() {
    HomeTheaterFacade theater;
    theater.watchMovie("Inception");
    // ... watch movie ...
    theater.endMovie();
}

#include <iostream>
#include <string>
#include <memory>

// Legacy players
class VLCPlayer {
public:
    void playVLC(const std::string& filename) {
        std::cout << "VLC: Playing " << filename << std::endl;
    }
};

class MP4Player {
public:
    void playMP4(const std::string& filename) {
        std::cout << "MP4 Player: Playing " << filename << std::endl;
    }
};

// Modern interface
class MediaPlayer {
public:
    virtual ~MediaPlayer() = default;
    virtual void play(const std::string& filename) = 0;
};

// Adapter
class MediaAdapter : public MediaPlayer {
public:
    void play(const std::string& filename) override {
        std::string ext = filename.substr(filename.find_last_of('.') + 1);
        
        if (ext == "vlc") {
            vlcPlayer_.playVLC(filename);
        } else if (ext == "mp4") {
            mp4Player_.playMP4(filename);
        } else {
            std::cout << "Unsupported format: " << ext << std::endl;
        }
    }
    
private:
    VLCPlayer vlcPlayer_;
    MP4Player mp4Player_;
};

// Client
class AudioPlayer : public MediaPlayer {
public:
    void play(const std::string& filename) override {
        std::string ext = filename.substr(filename.find_last_of('.') + 1);
        
        if (ext == "mp3") {
            std::cout << "AudioPlayer: Playing " << filename << std::endl;
        } else {
            adapter_.play(filename);
        }
    }
    
private:
    MediaAdapter adapter_;
};

int main() {
    AudioPlayer player;
    player.play("song.mp3");     // Native support
    player.play("video.mp4");    // Via adapter
    player.play("stream.vlc");   // Via adapter
}

Behavioral patterns are concerned with communication between objects, how they operate together, and how responsibilities are distributed among them.

The Observer Pattern

The Observer pattern defines a one-to-many dependency between objects. When one object (the "subject") changes state, all its dependents ("observers") are notified automatically. Think of it like a newsletter subscription - when a new article is published, all subscribers get notified.

This pattern is fundamental to event-driven programming. It's used extensively in GUI frameworks (button click handlers), reactive programming, and the Model-View-Controller (MVC) architecture.

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

// Observer interface
class Observer {
public:
    virtual ~Observer() = default;
    virtual void update(const std::string& message) = 0;
};

// Subject (Observable) class
class NewsAgency {
public:
    void subscribe(Observer* observer) {
        observers_.push_back(observer);
    }

    void unsubscribe(Observer* observer) {
        observers_.erase(
            std::remove(observers_.begin(), observers_.end(), observer),
            observers_.end()
        );
    }

    
    void publishNews(const std::string& news) {
        std::cout << "News Agency publishing: " << news << std::endl;
        notifyAll(news);
    }

private:
    void notifyAll(const std::string& message) {
        for (Observer* observer : observers_) {
            observer->update(message);
        }
    }
    
    std::vector<Observer*> observers_;
};

// Concrete observers
class NewsChannel : public Observer {
public:
    NewsChannel(const std::string& name) : name_(name) {}
    
    void update(const std::string& message) override {
        std::cout << name_ << " received: " << message << std::endl;
    }
    
private:
    std::string name_;
};

class NewsApp : public Observer {
public:
    NewsApp(const std::string& name) : name_(name) {}
    
    void update(const std::string& message) override {
        std::cout << name_ << " notification: " << message << std::endl;
    }
    
private:
    std::string name_;
};

int main() {
    NewsAgency agency;
    
    NewsChannel cnn("CNN");
    NewsChannel bbc("BBC");
    NewsApp mobileApp("NewsApp");
    
    // Subscribe to news
    agency.subscribe(&cnn);
    agency.subscribe(&bbc);
    agency.subscribe(&mobileApp);
    
    // Publish news - all observers notified
    agency.publishNews("Breaking: C++ 26 features announced!");
    
    std::cout << "\n--- BBC unsubscribes ---\n" << std::endl;
    agency.unsubscribe(&bbc);
    
    // Only CNN and NewsApp receive this
    agency.publishNews("Tech stocks rally on AI news");
    
    return 0;
}
// Output:
// News Agency publishing: Breaking: C++ 26 features announced!
// CNN received: Breaking: C++ 26 features announced!
// BBC received: Breaking: C++ 26 features announced!
// NewsApp notification: Breaking: C++ 26 features announced!
//
// --- BBC unsubscribes ---
//
// News Agency publishing: Tech stocks rally on AI news
// CNN received: Tech stocks rally on AI news
// NewsApp notification: Tech stocks rally on AI news

The Strategy Pattern

The Strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. It lets the algorithm vary independently from the clients that use it. Think of it like choosing a payment method at checkout - you can pay with credit card, PayPal, or cash. Each is a different "strategy" for payment.

This pattern is great when you have multiple ways to perform an operation and want to switch between them at runtime. It follows the Open/Closed Principle - you can add new strategies without modifying existing code.

#include <iostream>
#include <memory>
#include <vector>
#include <algorithm>

// Strategy interface
class SortStrategy {
public:
    virtual ~SortStrategy() = default;
    virtual void sort(std::vector<int>& data) = 0;
    virtual std::string getName() const = 0;
};

// Concrete strategies
class BubbleSort : public SortStrategy {
public:
    void sort(std::vector<int>& data) override {
        for (size_t i = 0; i < data.size(); ++i) {
            for (size_t j = 0; j < data.size() - i - 1; ++j) {
                if (data[j] > data[j + 1]) {
                    std::swap(data[j], data[j + 1]);
                }
            }
        }
    }
    
    std::string getName() const override { return "Bubble Sort"; }
};

class QuickSort : public SortStrategy {
public:
    void sort(std::vector<int>& data) override {
        quickSort(data, 0, data.size() - 1);
    }
    
    std::string getName() const override { return "Quick Sort"; }
    
private:
    void quickSort(std::vector<int>& arr, int low, int high) {
        if (low < high) {
            int pivot = partition(arr, low, high);
            quickSort(arr, low, pivot - 1);
            quickSort(arr, pivot + 1, high);
        }
    }
    
    int partition(std::vector<int>& arr, int low, int high) {
        int pivot = arr[high];
        int i = low - 1;
        for (int j = low; j < high; ++j) {
            if (arr[j] <= pivot) {
                ++i;
                std::swap(arr[i], arr[j]);
            }
        }
        std::swap(arr[i + 1], arr[high]);
        return i + 1;
    }
};

class STLSort : public SortStrategy {
public:
    void sort(std::vector<int>& data) override {
        std::sort(data.begin(), data.end());
    }
    
    std::string getName() const override { return "STL Sort"; }
};

// Context class that uses the strategy
class Sorter {
public:
    void setStrategy(std::unique_ptr<SortStrategy> strategy) {
        strategy_ = std::move(strategy);
    }
    
    void performSort(std::vector<int>& data) {
        if (strategy_) {
            std::cout << "Using " << strategy_->getName() << std::endl;
            strategy_->sort(data);
        }
    }
    
private:
    std::unique_ptr<SortStrategy> strategy_;
};

void printVector(const std::vector<int>& v) {
    for (int n : v) std::cout << n << " ";
    std::cout << std::endl;
}

int main() {
    Sorter sorter;
    std::vector<int> data = {64, 34, 25, 12, 22, 11, 90};
    
    std::cout << "Original: ";
    printVector(data);
    
    // Use Bubble Sort
    sorter.setStrategy(std::make_unique<BubbleSort>());
    auto copy1 = data;
    sorter.performSort(copy1);
    std::cout << "Result: ";
    printVector(copy1);
    
    // Switch to Quick Sort at runtime
    sorter.setStrategy(std::make_unique<QuickSort>());
    auto copy2 = data;
    sorter.performSort(copy2);
    std::cout << "Result: ";
    printVector(copy2);
    
    return 0;
}

The Command Pattern

The Command pattern encapsulates a request as an object, letting you parameterize clients with different requests, queue requests, and support undoable operations. Think of it like a restaurant order ticket - the waiter writes down your order (command), passes it to the kitchen (invoker), which executes it. The order can be modified, cancelled, or kept for records.

This pattern is essential for implementing undo/redo functionality, transaction systems, macro recording, and command queuing. Each command knows how to execute itself and optionally how to undo itself.

#include <iostream>
#include <memory>
#include <vector>
#include <stack>
#include <string>

// Receiver - the actual object that performs the work
class TextEditor {
public:
    void insertText(const std::string& text, size_t position) {
        content_.insert(position, text);
    }
    
    void deleteText(size_t position, size_t length) {
        content_.erase(position, length);
    }
    
    std::string getContent() const { return content_; }
    size_t getLength() const { return content_.length(); }
    
private:
    std::string content_;
};

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

// Concrete commands
class InsertCommand : public Command {
public:
    InsertCommand(TextEditor& editor, const std::string& text, size_t pos)
        : editor_(editor), text_(text), position_(pos) {}
    
    void execute() override {
        editor_.insertText(text_, position_);
    }
    
    void undo() override {
        editor_.deleteText(position_, text_.length());
    }
    
private:
    TextEditor& editor_;
    std::string text_;
    size_t position_;
};

class DeleteCommand : public Command {
public:
    DeleteCommand(TextEditor& editor, size_t pos, size_t len)
        : editor_(editor), position_(pos), length_(len) {
        // Save deleted text for undo
        deletedText_ = editor_.getContent().substr(pos, len);
    }
    
    void execute() override {
        editor_.deleteText(position_, length_);
    }
    
    void undo() override {
        editor_.insertText(deletedText_, position_);
    }
    
private:
    TextEditor& editor_;
    size_t position_;
    size_t length_;
    std::string deletedText_;
};

// Invoker - manages command execution and history
class CommandManager {
public:
    void executeCommand(std::unique_ptr<Command> cmd) {
        cmd->execute();
        history_.push(std::move(cmd));
        // Clear redo stack when new command is executed
        while (!redoStack_.empty()) redoStack_.pop();
    }

    void undo() {
        if (!history_.empty()) {
            auto cmd = std::move(history_.top());
            history_.pop();
            cmd->undo();
            redoStack_.push(std::move(cmd));
        }
    }

    void redo() {
        if (!redoStack_.empty()) {
            auto cmd = std::move(redoStack_.top());
            redoStack_.pop();
            cmd->execute();
            history_.push(std::move(cmd));
        }
    }
    
private:
    std::stack<std::unique_ptr<Command>> history_;
    std::stack<std::unique_ptr<Command>> redoStack_;
};

int main() {
    TextEditor editor;
    CommandManager manager;
    
    // Execute commands
    manager.executeCommand(
        std::make_unique<InsertCommand>(editor, "Hello", 0));
    std::cout << "After insert: " << editor.getContent() << std::endl;
    
    manager.executeCommand(
        std::make_unique<InsertCommand>(editor, " World", 5));
    std::cout << "After insert: " << editor.getContent() << std::endl;
    
    // Undo
    manager.undo();
    std::cout << "After undo: " << editor.getContent() << std::endl;
    
    // Redo
    manager.redo();
    std::cout << "After redo: " << editor.getContent() << std::endl;
    
    return 0;
}
// Output:
// After insert: Hello
// After insert: Hello World
// After undo: Hello
// After redo: Hello World

#include <iostream>
#include <vector>
#include <string>

class WeatherObserver {
public:
    virtual void update(double temp) = 0;
    virtual ~WeatherObserver() = default;
};

class WeatherStation {
public:
    void subscribe(WeatherObserver* obs) { observers_.push_back(obs); }
    
    void setTemperature(double temp) {
        temperature_ = temp;
        for (auto* obs : observers_) {
            obs->update(temp);
        }
    }
    
private:
    double temperature_ = 0;
    std::vector<WeatherObserver*> observers_;
};

class Display : public WeatherObserver {
public:
    Display(const std::string& name) : name_(name) {}
    
    void update(double temp) override {
        std::cout << name_ << ": Temperature updated to " 
                  << temp << "°C" << std::endl;
    }
    
private:
    std::string name_;
};

int main() {
    WeatherStation station;
    Display phone("Phone");
    Display tv("TV");
    
    station.subscribe(&phone);
    station.subscribe(&tv);
    
    station.setTemperature(25.5);
    // Phone: Temperature updated to 25.5°C
    // TV: Temperature updated to 25.5°C
}

#include <iostream>
#include <memory>

class PaymentStrategy {
public:
    virtual ~PaymentStrategy() = default;
    virtual void pay(double amount) = 0;
};

class CreditCard : public PaymentStrategy {
public:
    CreditCard(const std::string& num) : cardNumber_(num) {}
    void pay(double amount) override {
        std::cout << "Paid $" << amount << " with Credit Card "
                  << cardNumber_.substr(cardNumber_.length()-4) << std::endl;
    }
private:
    std::string cardNumber_;
};

class PayPal : public PaymentStrategy {
public:
    PayPal(const std::string& email) : email_(email) {}
    void pay(double amount) override {
        std::cout << "Paid $" << amount << " via PayPal (" 
                  << email_ << ")" << std::endl;
    }
private:
    std::string email_;
};

class ShoppingCart {
public:
    void setPaymentMethod(std::unique_ptr<PaymentStrategy> method) {
        payment_ = std::move(method);
    }
    
    void checkout(double total) {
        if (payment_) payment_->pay(total);
    }
    
private:
    std::unique_ptr<PaymentStrategy> payment_;
};

int main() {
    ShoppingCart cart;
    
    cart.setPaymentMethod(std::make_unique<CreditCard>("1234567890123456"));
    cart.checkout(99.99);  // Paid $99.99 with Credit Card 3456
    
    cart.setPaymentMethod(std::make_unique<PayPal>("user@email.com"));
    cart.checkout(49.99);  // Paid $49.99 via PayPal
}

#include <iostream>
#include <stack>
#include <memory>

class Calculator {
public:
    double getValue() const { return value_; }
    void setValue(double v) { value_ = v; }
private:
    double value_ = 0;
};

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

class AddCommand : public Command {
public:
    AddCommand(Calculator& calc, double value) 
        : calc_(calc), value_(value) {}
    
    void execute() override { calc_.setValue(calc_.getValue() + value_); }
    void undo() override { calc_.setValue(calc_.getValue() - value_); }
    
private:
    Calculator& calc_;
    double value_;
};

class SubtractCommand : public Command {
public:
    SubtractCommand(Calculator& calc, double value) 
        : calc_(calc), value_(value) {}
    
    void execute() override { calc_.setValue(calc_.getValue() - value_); }
    void undo() override { calc_.setValue(calc_.getValue() + value_); }
    
private:
    Calculator& calc_;
    double value_;
};

class MultiplyCommand : public Command {
public:
    MultiplyCommand(Calculator& calc, double value) 
        : calc_(calc), value_(value) {}
    
    void execute() override { calc_.setValue(calc_.getValue() * value_); }
    void undo() override { calc_.setValue(calc_.getValue() / value_); }
    
private:
    Calculator& calc_;
    double value_;
};

class CalculatorInvoker {
public:
    void executeCommand(std::unique_ptr<Command> cmd) {
        cmd->execute();
        history_.push(std::move(cmd));
        while (!redoStack_.empty()) redoStack_.pop();
    }
    
    void undo() {
        if (history_.empty()) return;
        auto cmd = std::move(history_.top());
        history_.pop();
        cmd->undo();
        redoStack_.push(std::move(cmd));
    }
    
    void redo() {
        if (redoStack_.empty()) return;
        auto cmd = std::move(redoStack_.top());
        redoStack_.pop();
        cmd->execute();
        history_.push(std::move(cmd));
    }
    
private:
    std::stack<std::unique_ptr<Command>> history_;
    std::stack<std::unique_ptr<Command>> redoStack_;
};

int main() {
    Calculator calc;
    CalculatorInvoker invoker;
    
    invoker.executeCommand(std::make_unique<AddCommand>(calc, 10));
    std::cout << "After +10: " << calc.getValue() << std::endl;  // 10
    
    invoker.executeCommand(std::make_unique<MultiplyCommand>(calc, 5));
    std::cout << "After *5: " << calc.getValue() << std::endl;   // 50
    
    invoker.undo();
    std::cout << "After undo: " << calc.getValue() << std::endl; // 10
    
    invoker.redo();
    std::cout << "After redo: " << calc.getValue() << std::endl; // 50
}

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

class StockObserver {
public:
    virtual ~StockObserver() = default;
    virtual void update(const std::string& symbol, 
                       double oldPrice, double newPrice) = 0;
};

class Stock {
public:
    Stock(const std::string& symbol, double price) 
        : symbol_(symbol), price_(price) {}
    
    void subscribe(StockObserver* obs) {
        observers_.push_back(obs);
    }
    
    void unsubscribe(StockObserver* obs) {
        observers_.erase(
            std::remove(observers_.begin(), observers_.end(), obs),
            observers_.end());
    }
    
    void setPrice(double newPrice) {
        double oldPrice = price_;
        price_ = newPrice;
        notify(oldPrice, newPrice);
    }
    
    double getPrice() const { return price_; }
    std::string getSymbol() const { return symbol_; }
    
private:
    void notify(double oldPrice, double newPrice) {
        for (auto* obs : observers_) {
            obs->update(symbol_, oldPrice, newPrice);
        }
    }
    
    std::string symbol_;
    double price_;
    std::vector<StockObserver*> observers_;
};

class Investor : public StockObserver {
public:
    Investor(const std::string& name) : name_(name) {}
    
    void update(const std::string& symbol, 
               double oldPrice, double newPrice) override {
        std::cout << name_ << ": Stock " << symbol 
                  << " changed from $" << oldPrice 
                  << " to $" << newPrice;
        if (newPrice > oldPrice) {
            std::cout << " (+" << (newPrice - oldPrice) << ")";
        } else {
            std::cout << " (" << (newPrice - oldPrice) << ")";
        }
        std::cout << std::endl;
    }
    
private:
    std::string name_;
};

int main() {
    Stock apple("AAPL", 150.0);
    
    Investor john("John");
    Investor jane("Jane");
    
    apple.subscribe(&john);
    apple.subscribe(&jane);
    
    apple.setPrice(155.0);  // Both notified
    apple.setPrice(148.0);  // Both notified
    
    apple.unsubscribe(&jane);
    apple.setPrice(160.0);  // Only John notified
}

Modern C++ introduces powerful idioms that go beyond classic GoF patterns. These idioms leverage C++'s unique features like templates, RAII, and compile-time programming.

RAII - Resource Acquisition Is Initialization

RAII is perhaps the most important C++ idiom. The idea is simple: tie the lifecycle of a resource (memory, file handle, mutex lock, network connection) to the lifetime of an object. When the object is created, it acquires the resource. When the object is destroyed, it releases the resource.

This pattern eliminates resource leaks because C++ guarantees that destructors are called when objects go out of scope, even when exceptions are thrown. Smart pointers (unique_ptr, shared_ptr) are the most common examples of RAII in modern C++.

#include <iostream>
#include <fstream>
#include <mutex>
#include <memory>

// Custom RAII wrapper for file handling
class FileHandle {
public:
    explicit FileHandle(const std::string& filename) 
        : file_(filename) {
        if (!file_.is_open()) {
            throw std::runtime_error("Failed to open file: " + filename);
        }
        std::cout << "File opened: " << filename << std::endl;
    }

    ~FileHandle() {
        if (file_.is_open()) {
            file_.close();
            std::cout << "File closed automatically" << std::endl;
        }
    }

    // Delete copy operations
    FileHandle(const FileHandle&) = delete;
    FileHandle& operator=(const FileHandle&) = delete;
    
    // Allow move operations
    FileHandle(FileHandle&& other) noexcept : file_(std::move(other.file_)) {}
    
    void write(const std::string& data) {
        file_ << data;
    }
    
private:
    std::ofstream file_;
};

// RAII mutex lock
class LockGuard {
public:
    explicit LockGuard(std::mutex& mtx) : mutex_(mtx) {
        mutex_.lock();
        std::cout << "Mutex locked" << std::endl;
    }

    ~LockGuard() {
        mutex_.unlock();
        std::cout << "Mutex unlocked" << std::endl;
    }
    
    LockGuard(const LockGuard&) = delete;
    LockGuard& operator=(const LockGuard&) = delete;
    
private:
    std::mutex& mutex_;
};

void processWithLock(std::mutex& mtx) {
    LockGuard lock(mtx);  // Automatically locks
    
    // Do work...
    std::cout << "Processing..." << std::endl;
    
    // If exception thrown here, destructor still runs!
    // throw std::runtime_error("Error!");
    
}  // Automatically unlocks when lock goes out of scope

int main() {
    // Smart pointers are RAII for dynamic memory
    {
        auto ptr = std::make_unique<int>(42);
        std::cout << "Value: " << *ptr << std::endl;
    }  // Memory automatically freed here
    
    // File RAII
    try {
        FileHandle file("output.txt");
        file.write("Hello, RAII!\n");
        // File automatically closed when 'file' goes out of scope
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }
    
    // Mutex RAII
    std::mutex mtx;
    processWithLock(mtx);
    
    return 0;
}

CRTP - Curiously Recurring Template Pattern

CRTP is a template technique where a class inherits from a template instantiated with itself. It sounds mind-bending, but it's incredibly powerful for adding functionality to classes at compile time without the overhead of virtual functions.

Common uses include: implementing the Singleton pattern, adding comparison operators, implementing object counting, and creating compile-time polymorphism (static polymorphism).

#include <iostream>

// CRTP base - provides functionality to derived classes
template<typename Derived>
class Counter {
public:
    Counter() { ++count_; }
    Counter(const Counter&) { ++count_; }
    ~Counter() { --count_; }
    
    static int getCount() { return count_; }
    
private:
    static int count_;
};

template<typename Derived>
int Counter<Derived>::count_ = 0;

// Classes using CRTP - each gets its own counter!
class Dog : public Counter<Dog> {
public:
    Dog(const std::string& name) : name_(name) {}
    std::string name_;
};

class Cat : public Counter<Cat> {
public:
    Cat(const std::string& name) : name_(name) {}
    std::string name_;
};

int main() {
    Dog d1("Rex"), d2("Buddy"), d3("Max");
    Cat c1("Whiskers"), c2("Mittens");
    
    std::cout << "Dogs: " << Dog::getCount() << std::endl;  // 3
    std::cout << "Cats: " << Cat::getCount() << std::endl;  // 2
    
    {
        Dog temp("Temp");
        std::cout << "Dogs (with temp): " << Dog::getCount() << std::endl;  // 4
    }
    
    std::cout << "Dogs (after temp): " << Dog::getCount() << std::endl;  // 3
    
    return 0;
}

// CRTP for static polymorphism - no virtual function overhead!
template<typename Derived>
class Shape {
public:
    void draw() {
        // Call derived class implementation without virtual
        static_cast<Derived*>(this)->drawImpl();
    }
    
    double area() {
        return static_cast<Derived*>(this)->areaImpl();
    }
};

class Circle : public Shape<Circle> {
public:
    Circle(double r) : radius_(r) {}
    
    void drawImpl() {
        std::cout << "Drawing Circle with radius " << radius_ << std::endl;
    }
    
    double areaImpl() {
        return 3.14159 * radius_ * radius_;
    }
    
private:
    double radius_;
};

class Square : public Shape<Square> {
public:
    Square(double s) : side_(s) {}
    
    void drawImpl() {
        std::cout << "Drawing Square with side " << side_ << std::endl;
    }
    
    double areaImpl() {
        return side_ * side_;
    }
    
private:
    double side_;
};

Pimpl - Pointer to Implementation

The Pimpl (Pointer to Implementation) idiom hides implementation details from the header file. Only a forward declaration of the implementation class appears in the header - all the actual implementation is in the source file. This reduces compilation dependencies and compile times.

When you change implementation details (private members), only the .cpp file needs recompilation - not all the files that include the header. This is especially valuable in large projects.

// Widget.h - Header file (minimal dependencies)
#ifndef WIDGET_H
#define WIDGET_H

#include <memory>
#include <string>

class Widget {
public:
    Widget(const std::string& name);
    ~Widget();  // Must be declared for unique_ptr with incomplete type

    // Move operations
    Widget(Widget&& other) noexcept;
    Widget& operator=(Widget&& other) noexcept;
    
    // Public interface
    void doSomething();
    std::string getName() const;

private:
    class Impl;  // Forward declaration only!
    std::unique_ptr<Impl> pImpl_;
};

#endif

// Widget.cpp - Implementation file (all the details hidden here)
#include "Widget.h"
#include <iostream>
#include <vector>  // Only needed in .cpp, not exposed in header

class Widget::Impl {
public:
    Impl(const std::string& name) : name_(name) {}
    
    void doSomething() {
        std::cout << "Widget " << name_ << " doing something!" << std::endl;
        for (int i = 0; i < 3; ++i) {
            data_.push_back(i);
        }
    }
    
    std::string getName() const { return name_; }
    
private:
    std::string name_;
    std::vector<int> data_;  // Implementation detail hidden from header
};

Widget::Widget(const std::string& name) 
    : pImpl_(std::make_unique<Impl>(name)) {}

Widget::~Widget() = default;

Widget::Widget(Widget&&) noexcept = default;
Widget& Widget::operator=(Widget&&) noexcept = default;

void Widget::doSomething() {
    pImpl_->doSomething();
}

std::string Widget::getName() const {
    return pImpl_->getName();
}

#include <iostream>
#include <chrono>
#include <thread>

class Timer {
public:
    Timer() : start_(std::chrono::high_resolution_clock::now()) {}
    
    ~Timer() {
        auto end = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(
            end - start_);
        std::cout << "Elapsed: " << duration.count() << " ms" << std::endl;
    }
    
private:
    std::chrono::high_resolution_clock::time_point start_;
};

int main() {
    {
        Timer t;
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        // Destructor prints elapsed time
    }  // Elapsed: ~100 ms
    
    return 0;
}

#include <iostream>

template<typename Derived>
class Comparable {
public:
    bool operator<(const Derived& other) const {
        return derived().compareTo(other) < 0;
    }
    bool operator>(const Derived& other) const {
        return derived().compareTo(other) > 0;
    }
    bool operator<=(const Derived& other) const {
        return derived().compareTo(other) <= 0;
    }
    bool operator>=(const Derived& other) const {
        return derived().compareTo(other) >= 0;
    }
    bool operator==(const Derived& other) const {
        return derived().compareTo(other) == 0;
    }
    bool operator!=(const Derived& other) const {
        return derived().compareTo(other) != 0;
    }
    
private:
    const Derived& derived() const {
        return static_cast<const Derived&>(*this);
    }
};

class Person : public Comparable<Person> {
public:
    Person(int age) : age_(age) {}
    
    int compareTo(const Person& other) const {
        if (age_ < other.age_) return -1;
        if (age_ > other.age_) return 1;
        return 0;
    }
    
private:
    int age_;
};

int main() {
    Person p1(25), p2(30);
    
    std::cout << (p1 < p2) << std::endl;   // 1 (true)
    std::cout << (p1 == p2) << std::endl;  // 0 (false)
}

// Database.h
#ifndef DATABASE_H
#define DATABASE_H

#include <memory>
#include <string>

class Database {
public:
    Database();
    ~Database();
    
    Database(Database&&) noexcept;
    Database& operator=(Database&&) noexcept;
    
    bool connect(const std::string& connectionString);
    void disconnect();
    bool query(const std::string& sql);
    bool isConnected() const;
    
private:
    class Impl;
    std::unique_ptr<Impl> pImpl_;
};

#endif

// Database.cpp
#include "Database.h"
#include <iostream>
#include <vector>  // Hidden from header

class Database::Impl {
public:
    bool connect(const std::string& connStr) {
        std::cout << "Connecting to: " << connStr << std::endl;
        connectionString_ = connStr;
        connected_ = true;
        return true;
    }
    
    void disconnect() {
        if (connected_) {
            std::cout << "Disconnecting..." << std::endl;
            connected_ = false;
        }
    }
    
    bool query(const std::string& sql) {
        if (!connected_) return false;
        std::cout << "Executing: " << sql << std::endl;
        queryHistory_.push_back(sql);
        return true;
    }
    
    bool isConnected() const { return connected_; }
    
private:
    std::string connectionString_;
    bool connected_ = false;
    std::vector<std::string> queryHistory_;  // Hidden detail
};

Database::Database() : pImpl_(std::make_unique<Impl>()) {}
Database::~Database() = default;
Database::Database(Database&&) noexcept = default;
Database& Database::operator=(Database&&) noexcept = default;

bool Database::connect(const std::string& cs) { return pImpl_->connect(cs); }
void Database::disconnect() { pImpl_->disconnect(); }
bool Database::query(const std::string& sql) { return pImpl_->query(sql); }
bool Database::isConnected() const { return pImpl_->isConnected(); }

// main.cpp
int main() {
    Database db;
    db.connect("mysql://localhost:3306/mydb");
    db.query("SELECT * FROM users");
    db.disconnect();
}

#include <iostream>
#include <string>
#include <stdexcept>

class DatabaseConnection {
public:
    explicit DatabaseConnection(const std::string& connStr) 
        : connectionString_(connStr), connected_(false) {
        // Simulate connection
        std::cout << "Opening connection to: " << connStr << std::endl;
        connected_ = true;
        std::cout << "Connection established!" << std::endl;
    }
    
    ~DatabaseConnection() {
        if (connected_) {
            std::cout << "Closing connection to: " << connectionString_ << std::endl;
            connected_ = false;
            std::cout << "Connection closed." << std::endl;
        }
    }
    
    // Non-copyable
    DatabaseConnection(const DatabaseConnection&) = delete;
    DatabaseConnection& operator=(const DatabaseConnection&) = delete;
    
    // Allow move
    DatabaseConnection(DatabaseConnection&& other) noexcept 
        : connectionString_(std::move(other.connectionString_)),
          connected_(other.connected_) {
        other.connected_ = false;
    }
    
    void execute(const std::string& query) {
        if (!connected_) {
            throw std::runtime_error("Not connected!");
        }
        std::cout << "Executing: " << query << std::endl;
    }
    
    bool isConnected() const { return connected_; }
    
private:
    std::string connectionString_;
    bool connected_;
};

void processData() {
    DatabaseConnection conn("mysql://localhost/test");
    conn.execute("SELECT * FROM users");
    conn.execute("UPDATE users SET active=1");
    // Connection automatically closed when conn goes out of scope
}

int main() {
    std::cout << "=== Starting process ===" << std::endl;
    processData();
    std::cout << "=== Process complete ===" << std::endl;
    // Output shows connection is properly closed
}