C++观察者模式如何设计 使用现代C++实现事件通知机制

std::function

#include <iostream>
#include <vector>
#include <functional>
#include <memory> // For std::shared_ptr, std::weak_ptr
#include <algorithm> // For std::remove_if

// 定义一个通用的事件数据结构，或者直接传递可变参数
struct EventData {
    std::string message;
    int value;
};

// Subject类
class Subject {
public:
    // 回调类型，这里以EventData为例，也可以是void()或其它签名
    using Callback = std::function<void(const EventData&)>;

    // 注册观察者：返回一个shared_ptr，方便外部管理其生命周期，
    // 内部存储weak_ptr，避免循环引用和悬空指针
    std::shared_ptr<Callback> attach(Callback cb) {
        auto shared_cb = std::make_shared<Callback>(std::move(cb));
        observers_.push_back(std::weak_ptr<Callback>(shared_cb));
        // 清理无效的弱指针（已销毁的观察者）
        cleanup_observers();
        return shared_cb;
    }

    // 移除观察者：通过比较shared_ptr的地址来移除
    void detach(std::shared_ptr<Callback> cb_handle) {
        observers_.erase(
            std::remove_if(observers_.begin(), observers_.end(),
                [&](const std::weak_ptr<Callback>& wp) {
                    return wp.lock() == cb_handle;
                }),
            observers_.end());
    }

    // 通知所有观察者
    void notify(const EventData& data) {
        cleanup_observers(); // 再次清理，确保通知时列表是干净的
        for (const auto& wp : observers_) {
            if (auto sp = wp.lock()) { // 尝试锁定弱指针，如果对象还存在
                (*sp)(data); // 调用回调
            }
        }
    }

    // 模拟状态改变
    void changeState(const std::string& msg, int val) {
        std::cout << "Subject state changed to: " << msg << ", " << val << std::endl;
        notify({msg, val});
    }

private:
    std::vector<std::weak_ptr<Callback>> observers_;

    // 内部清理已失效的弱指针
    void cleanup_observers() {
        observers_.erase(
            std::remove_if(observers_.begin(), observers_.end(),
                [](const std::weak_ptr<Callback>& wp) {
                    return wp.expired(); // 检查弱指针是否已过期（指向的对象已销毁）
                }),
            observers_.end());
    }
};

// 示例观察者类
class ConcreteObserver {
public:
    ConcreteObserver(const std::string& name) : name_(name) {}

    void onEvent(const EventData& data) {
        std::cout << "[" << name_ << "] Received event: "
                  << data.message << ", Value: " << data.value << std::endl;
    }

private:
    std::string name_;
};

/*
int main() {
    Subject subject;

    // 观察者1：使用lambda表达式
    auto obs1_handle = subject.attach([](const EventData& data) {
        std::cout << "[Lambda Observer] Event: " << data.message << std::endl;
    });

    // 观察者2：使用成员函数
    ConcreteObserver observer2("ObserverB");
    // std::bind 可以将成员函数绑定到特定对象实例上
    auto obs2_handle = subject.attach(std::bind(&ConcreteObserver::onEvent, &observer2, std::placeholders::_1));

    // 观察者3：一个临时对象，生命周期结束后会自动从Subject中移除（因为weak_ptr）
    {
        ConcreteObserver observer3("ObserverC");
        auto obs3_handle = subject.attach(std::bind(&ConcreteObserver::onEvent, &observer3, std::placeholders::_1));
        subject.changeState("First update", 10);
    } // observer3 在这里销毁，其对应的 weak_ptr 会失效

    std::cout << "\n--- After ObserverC destroyed ---\n";
    subject.changeState("Second update", 20);

    // 手动移除观察者1
    subject.detach(obs1_handle);
    std::cout << "\n--- After Lambda Observer detached ---\n";
    subject.changeState("Third update", 30);

    return 0;
}
*/

Observer

update()

update

update

void*

static_cast

dynamic_cast

Observer

std::shared_ptr

std::weak_ptr

std::function

std::function

std::weak_ptr

std::function

std::weak_ptr

std::function

Observer

update

std::function<void(const EventData&)>

std::weak_ptr

std::weak_ptr

std::weak_ptr<std::function<...>>

weak_ptr

std::shared_ptr

wp.lock()

lock()

nullptr

std::function

std::mutex

// Subject类中添加一个互斥锁
class Subject {
    // ...
private:
    std::vector<std::weak_ptr<Callback>> observers_;
    mutable std::mutex observers_mutex_; // 可变互斥锁，因为notify可能在const方法中调用
    // ...

public:
    std::shared_ptr<Callback> attach(Callback cb) {
        std::lock_guard<std::mutex> lock(observers_mutex_); // 锁定
        // ... (原有的添加逻辑)
        cleanup_observers();
        return shared_cb;
    }

    void detach(std::shared_ptr<Callback> cb_handle) {
        std::lock_guard<std::mutex> lock(observers_mutex_); // 锁定
        // ... (原有的移除逻辑)
    }

    void notify(const EventData& data) {
        // 在通知前，复制一份观察者列表，然后释放锁，避免在回调中发生死锁
        std::vector<std::shared_ptr<Callback>> current_observers;
        {
            std::lock_guard<std::mutex> lock(observers_mutex_);
            cleanup_observers(); // 在锁定状态下清理
            for (const auto& wp : observers_) {
                if (auto sp = wp.lock()) {
                    current_observers.push_back(sp);
                }
            }
        } // 锁在这里释放

        // 现在可以安全地通知，即使回调中尝试修改observers_列表也不会死锁
        for (const auto& sp : current_observers) {
            (*sp)(data);
        }
    }
    // ...
};

notify

std::weak_ptr

this

weak_ptr

try-catch

// notify方法中的异常安全
void notify(const EventData& data) {
    // ... (复制列表和释放锁的部分)
    for (const auto& sp : current_observers) {
        try {
            (*sp)(data);
        } catch (const std::exception& e) {
            std::cerr << "Error notifying observer: " << e.what() << std::endl;
            // 可以在这里选择是否继续通知其他观察者
        } catch (...) {
            std::cerr << "Unknown error notifying observer." << std::endl;
        }
    }
}