设计模式

单例模式（Singleton）

单例模式确保：

一个类只有一个实例
全局可访问这个实例

典型用途：日志系统、配置管理器、数据库连接池、线程池等。

“懒汉式”与“饿汉式”的区别

饿汉式: 程序启动时就创建实例, 简单、线程安全（初始化时机唯一）可能浪费资源

懒汉式: 第一次使用时才创建实例,延迟加载、节省资源,需要考虑线程安全

class Singleton {
private:
    Singleton() {}                     // 私有构造
    ~Singleton() {}                    // 可选：防止外部析构
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
public:
    static Singleton& getInstance() {
        static Singleton instance;     // C++11保证线程安全初始化
        return instance;
    }
};

Factory Method

创建不同的子类对象

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

class Circle : public Shape { /*...*/ };
class Rect   : public Shape { /*...*/ };

std::unique_ptr<Shape> createShape(const std::string& type) {
    if (type == "circle") return std::make_unique<Circle>();
    if (type == "rect")   return std::make_unique<Rect>();
    return nullptr;
}

Strategy

class SortStrategy {
public:
    virtual ~SortStrategy() = default;
    virtual void sort(std::vector<int>& data) = 0;
};

class QuickSort : public SortStrategy { /*...*/ };
class MergeSort : public SortStrategy { /*...*/ };

class Context {
public:
    explicit Context(std::unique_ptr<SortStrategy> s)
      : strategy_(std::move(s)) {}

    void setStrategy(std::unique_ptr<SortStrategy> s) {
        strategy_ = std::move(s);
    }
    void doSort(std::vector<int>& data) {
        strategy_->sort(data);
    }
private:
    std::unique_ptr<SortStrategy> strategy_;
};

Observer

场景：一对多通知：GUI 事件、订阅/发布、配置更新、游戏事件等。

class Observer {
public:
    virtual ~Observer() = default;
    virtual void onNotify(int data) = 0;
};

class Subject {
public:
    void addObserver(Observer* o) { obs_.push_back(o); }
    void notify(int data) {
        for (auto o : obs_) o->onNotify(data);
    }
private:
    std::vector<Observer*> obs_;
};

Reactor pattern

在有成千上万连接时，避免“一个连接一个线程”的资源浪费，用事件驱动 + 非阻塞 IO来处理大量并发连接。

Proactor Pattern

Proxy Pattern

代理模式（Proxy Pattern）：为某个对象提供一个替身/中介（代理），由代理控制对真实对象的访问。对外接口不变，调用方“看起来”在用目标对象，实际上请求会先经过代理