现代 C++ 结构型与行为型模式 on Dorkytiger 的小屋

策略模式——用 std::function 替代虚类

Mon, 01 Jan 0001 00:00:00 +0000

一、问题场景

传统策略模式（GoF 风格）：

// 抽象策略类
struct CompressionStrategy {
    virtual std::vector<char> compress(const std::vector<char>&) = 0;
    virtual ~CompressionStrategy() = default;
};

struct GzipStrategy : CompressionStrategy { ... };
struct ZstdStrategy : CompressionStrategy { ... };

// 使用策略
class Compressor {
    std::unique_ptr<CompressionStrategy> strategy_;
public:
    void setStrategy(std::unique_ptr<CompressionStrategy> s) {
        strategy_ = std::move(s);
    }
};

问题：用户必须继承 CompressionStrategy、必须传 unique_ptr、必须处理所有权转移。

二、现代写法

class Compressor {
    // 用 std::function 替代虚基类
    std::function<std::vector<char>(const std::vector<char>&)> strategy_;

public:
    // 接受任何可调用对象：lambda、函数指针、函数对象
    void setStrategy(std::function<std::vector<char>(const std::vector<char>&)> s) {
        strategy_ = std::move(s);
    }

    std::vector<char> compress(const std::vector<char>& data) {
        if (!strategy_) throw std::runtime_error("no strategy set");
        return strategy_(data);
    }
};

// 使用——用户不需要继承任何东西
Compressor comp;
comp.setStrategy([](const auto& data) -> std::vector<char> {
    // 在这里写 gzip 压缩逻辑
    return data;
});

现代写法 vs 传统写法：

观察者模式——用 vector\ 替代虚基类

Mon, 01 Jan 0001 00:00:00 +0000

一、传统观察者 vs 现代写法

传统：

struct Observer {
    virtual void onEvent(const Event&) = 0;
};

class Subject {
    std::vector<Observer*> observers_;
public:
    void attach(Observer* o) { observers_.push_back(o); }
    void notify(const Event& e) {
        for (auto* o : observers_) o->onEvent(e);
    }
};

问题：Observer 必须继承虚基类，生命周期由 Subject 外部管理（悬垂指针风险）。

现代写法：

class EventBus {
    std::vector<std::function<void(const Event&)>> handlers_;

public:
    // 接受 lambda、函数指针、任何可调用对象
    template <typename F>
    void subscribe(F&& handler) {
        handlers_.push_back(std::forward<F>(handler));
    }

    void fire(const Event& event) {
        for (auto& h : handlers_) {
            h(event);
        }
    }
};

// 使用——不需要继承任何东西
EventBus bus;
bus.subscribe([](const Event& e) {
    std::cout << "received: " << e.type << "\n";
});

Server server;
server.on_connect([&bus](ConnectionPtr conn) {
    bus.fire(Event{"connected"});
});

二、生命周期管理

现代观察者模式的最大问题：订阅者的生命周期。如果订阅者先于 EventBus 销毁，但订阅 lambda 捕获了订阅者的 this 指针，EventBus 触发事件时就是 Use-After-Free。

RAII 封装——ScopeGuard

Mon, 01 Jan 0001 00:00:00 +0000

一、RAII 的本质

RAII（Resource Acquisition Is Initialization）的核心思想：资源获取和对象构造绑定，资源释放和对象析构绑定。

你每天都在用：

std::lock_guard<std::mutex> lock(mtx);  // 构造时 lock，析构时 unlock
std::ifstream file("data.txt");          // 构造时 open，析构时 close
std::unique_ptr<Foo> ptr(new Foo);       // 构造时 new，析构时 delete

二、ScopeGuard——通用的 RAII 封装

场景：函数中间有多个 return 点，每个 return 前都要做同样的清理：

void process() {
    FILE* f = fopen("data.txt", "r");
    // ... 如果这里 return 了，f 没关
    if (something) return;
    // ... 如果这里抛异常，f 没关
    fclose(f);
}

ScopeGuard 让你在构造时注册一个清理函数，析构时自动执行：

class ScopeGuard {
    std::function<void()> cleanup_;
    bool active_ = true;
public:
    explicit ScopeGuard(std::function<void()> cleanup)
        : cleanup_(std::move(cleanup)) {}

    ~ScopeGuard() {
        if (active_) cleanup_();  // 析构时执行清理
    }

    // 如果成功，可以调用 dismiss 取消清理
    void dismiss() { active_ = false; }
};

void process() {
    FILE* f = fopen("data.txt", "r");
    ScopeGuard close_file([&] { if (f) fclose(f); });

    if (something) return;  // 析构 ScopeGuard → 自动 fclose
    // ... 正常处理
    close_file.dismiss();    // 成功，不再需要自动清理
    fclose(f);               // 手动关闭
}

更简洁的宏（很多 C++ 项目这么用）：

写时复制（Copy-on-Write）

Mon, 01 Jan 0001 00:00:00 +0000

一、场景

你有大量对象共享同一份数据。大部分操作只是读数据，偶尔写。如果每次拷贝都深复制一份，浪费内存和 CPU。

COW 的思路：读操作共享同一份数据，写操作才复制。

class SharedBuffer {
    struct Data {
        std::vector<char> buf;
        int ref_count = 1;
    };

    Data* data_;

public:
    SharedBuffer() : data_(new Data()) {}

    // 浅拷贝：共享同一个 Data
    SharedBuffer(const SharedBuffer& other)
        : data_(other.data_) {
        data_->ref_count++;
    }

    ~SharedBuffer() {
        if (--data_->ref_count == 0) {
            delete data_;  // 最后一个引用才释放
        }
    }

    // 读操作：共享，不需要复制
    const char* read() const {
        return data_->buf.data();
    }

    // 写操作：先检查引用计数，如果共享了就要复制
    char* write() {
        if (data_->ref_count > 1) {
            // 有人在共享，先复制一份
            Data* new_data = new Data(*data_);
            new_data->ref_count = 1;
            data_->ref_count--;
            data_ = new_data;
        }
        return data_->buf.data();
    }
};

二、面试追问 Q&A

Q1：std::string 为什么 C++11 后不再用 COW？ A：COW 在多线程下有严重问题。判断"是否共享"需要原子操作，且 operator[] 返回的引用可能被用作写操作，但你无法在返回引用时复制。C++11 起标准要求 operator[] 是 $O(1)$ 且不修改 this，所以 COW 被 SSO（Short String Optimization）替代了。