c++如何实现观察者模式_C++发布订阅机制的设计实例

观察者模式通过定义一对多依赖关系，实现对象间松耦合通信。1. 使用抽象接口：定义Observer基类和Subject类，通过继承与虚函数实现通知机制，适合需要多态的场景。2. 使用std::function：以函数对象替代继承，支持lambda、函数指针等可调用对象，提升灵活性。3. 智能指针版本：结合shared_ptr与weak_ptr自动管理订阅生命周期，避免悬空指针。适用于GUI事件、MVC架构、消息总线等场景，建议根据需求选择继承或回调方式，并注意线程安全与资源管理。

观察者模式（Observer Pattern），也叫发布-订阅模式，是一种行为设计模式，用于在对象之间定义一对多的依赖关系，当一个对象的状态发生变化时，所有依赖它的对象都会自动收到通知。在 C++ 中实现这一机制，可以通过抽象基类、函数指针、std::function 或智能指针等现代 C++ 特性来完成。

1. 使用抽象接口实现观察者模式

这是最经典的方式，通过定义观察者和被观察者的抽象接口，实现松耦合通信。

步骤说明：

• 定义一个 Observer 抽象类，包含纯虚函数 update()。
• 定义一个 Subject 类，维护观察者列表，提供注册、移除和通知接口。
• 具体观察者继承 Observer，实现自己的 update 行为。

代码示例：

立即学习“C++免费学习笔记（深入）”；

#include 
#include 
#include 
class Observer;
class Subject {
private:
std::vector observers;
int state;
public:
void attach(Observer obs);
void detach(Observer obs);
void notify();
void setState(int s);
int getState() const { return state; }
};
class Observer {
protected:
Subject subject;
public:
explicit Observer(Subject s) : subject(s) {
subject->attach(this);
}
virtual ~Observer() {
subject->detach(this);
}
virtual void update() = 0;
};
void Subject::attach(Observer* obs) {
observers.push_back(obs);
}
void Subject::detach(Observer* obs) {
observers.erase(
std::remove(observers.begin(), observers.end(), obs),
observers.end()
);
}
void Subject::notify() {
for (auto obs : observers) {
obs->update();
}
}
void Subject::setState(int s) {
state = s;
notify();
}
// 具体观察者
class ConcreteObserverA : public Observer {
public:
explicit ConcreteObserverA(Subject* s) : Observer(s) {}
void update() override {
std::cout << "Observer A: Subject state is now " << subject->getState() << "\n";
}
};
class ConcreteObserverB : public Observer {
public:
explicit ConcreteObserverB(Subject* s) : Observer(s) {}
void update() override {
std::cout << "Observer B: Subject state changed to " << subject->getState() << "\n";
}
};

使用方式：

int main() {
    Subject subject;
    ConcreteObserverA observerA(&subject);
    ConcreteObserverB observerB(&subject);
subject.setState(10);  // 两个观察者都会收到通知
subject.setState(20);

return 0;
}
2. 使用 std::function 实现更灵活的订阅机制
如果不想使用继承，可以用函数对象代替抽象类，让订阅者更加灵活，支持 lambda、函数指针或任意可调用对象。
#include 
#include 
#include 
#include 
class EventSystem {
private:
std::vector> listeners;
public:
// 订阅事件
void subscribe(std::function callback) {
listeners.push_back(callback);
}
// 发布事件
void publish(int value) {
    for (const auto& listener : listeners) {
        listener(value);
    }
}
};

							

								
								

									算家云
									
高效、便捷的人工智能算力服务平台
								
								下载 
							
						
使用示例：
int main() {
    EventSystem eventBus;
// 使用 lambda 订阅
eventBus.subscribe([](int val) {
    std::cout zuojiankuohaophpcnzuojiankuohaophpcn "Logger: Value updated to " zuojiankuohaophpcnzuojiankuohaophpcn val zuojiankuohaophpcnzuojiankuohaophpcn "\n";
});

eventBus.subscribe([](int val) {
    if (val youjiankuohaophpcn 50) {
        std::cout zuojiankuohaophpcnzuojiankuohaophpcn "Alert: High value detected: " zuojiankuohaophpcnzuojiankuohaophpcn val zuojiankuohaophpcnzuojiankuohaophpcn "\n";
    }
});

// 模拟数据变化
eventBus.publish(30);
eventBus.publish(60);

return 0;
}
3. 支持自动解绑的智能指针版本（进阶）
为了避免手动管理生命周期导致的悬空指针问题，可以结合 std::shared_ptr 和 weak_ptr 实现自动清理。
思路：每个订阅者返回一个句柄（token），当句柄销毁时自动从列表中移除。或者使用 weak_ptr 存储回调，在调用前检查是否有效。
#include 
#include 
#include 
#include 
class Publisher {
private:
struct CallbackWrapper {
std::weak_ptr> cb;
};
std::vector callbacks;
public:
std::shared_ptr> 
subscribe(std::function func) {
auto shared_func = std::make_shared>(func);
callbacks.push_back({shared_func});
return shared_func;  // 返回共享指针作为“订阅句柄”
}
void publish(int value) {
    callbacks.erase(
        std::remove_if(callbacks.begin(), callbacks.end(),
            [value](const CallbackWrapper& wrapper) {
                auto locked = wrapper.cb.lock();
                if (locked) {
                    (*locked)(value);
                    return false;
                }
                return true;  // 已失效，移除
            }),
        callbacks.end()
    );
}
};
这样当外部持有的 shared_ptr 被释放，下次 publish 时会自动清理无效项。
应用场景与建议
观察者模式适用于以下场景：

GUI 事件系统（按钮点击通知多个组件）
模型-视图架构中，模型更新通知视图刷新
日志系统、消息总线、状态监控等

设计建议：
- 若需要多态行为，使用接口 + 继承方式。
- 若注重灵活性和轻量级，推荐 std::function + 回调。
- 注意循环引用和生命周期管理，尤其是在使用智能指针时。
- 线程安全需额外加锁（如 std::mutex），若跨线程发布。
基本上就这些。根据项目复杂度选择合适实现方式即可。