观察者模式通过定义一对多依赖关系，实现对象间松耦合通信。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 <iostream>
#include <vector>
#include <algorithm>
<p>class Observer;</p><p>class Subject {
private:
std::vector<Observer*> observers;
int state;</p><p>public:
void attach(Observer<em> obs);
void detach(Observer</em> obs);
void notify();
void setState(int s);
int getState() const { return state; }
};</p><p>class Observer {
protected:
Subject<em> subject;
public:
explicit Observer(Subject</em> s) : subject(s) {
subject->attach(this);
}
virtual ~Observer() {
subject->detach(this);
}
virtual void update() = 0;
};</p><p>void Subject::attach(Observer* obs) {
observers.push_back(obs);
}</p><p>void Subject::detach(Observer* obs) {
observers.erase(
std::remove(observers.begin(), observers.end(), obs),
observers.end()
);
}</p><p>void Subject::notify() {
for (auto obs : observers) {
obs->update();
}
}</p><p>void Subject::setState(int s) {
state = s;
notify();
}</p><p>// 具体观察者
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";
}
};</p><p>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";
}
};</p>使用方式：
int main() {
Subject subject;
ConcreteObserverA observerA(&subject);
ConcreteObserverB observerB(&subject);
<pre class='brush:php;toolbar:false;'>subject.setState(10); // 两个观察者都会收到通知
subject.setState(20);
return 0;}
2. 使用 std::function 实现更灵活的订阅机制
如果不想使用继承，可以用函数对象代替抽象类，让订阅者更加灵活，支持 lambda、函数指针或任意可调用对象。
#include <iostream>
#include <vector>
#include <functional>
#include <algorithm>
<p>class EventSystem {
private:
std::vector<std::function<void(int)>> listeners;</p><p>public:
// 订阅事件
void subscribe(std::function<void(int)> callback) {
listeners.push_back(callback);
}</p><pre class='brush:php;toolbar:false;'>// 发布事件
void publish(int value) {
for (const auto& listener : listeners) {
listener(value);
}
}};
使用示例：
int main() {
EventSystem eventBus;
<pre class='brush:php;toolbar:false;'>// 使用 lambda 订阅
eventBus.subscribe([](int val) {
std::cout << "Logger: Value updated to " << val << "\n";
});
eventBus.subscribe([](int val) {
if (val > 50) {
std::cout << "Alert: High value detected: " << val << "\n";
}
});
// 模拟数据变化
eventBus.publish(30);
eventBus.publish(60);
return 0;}
3. 支持自动解绑的智能指针版本（进阶）
为了避免手动管理生命周期导致的悬空指针问题，可以结合 std::shared_ptr 和 weak_ptr 实现自动清理。
思路：每个订阅者返回一个句柄（token），当句柄销毁时自动从列表中移除。或者使用 weak_ptr 存储回调，在调用前检查是否有效。
#include <iostream>
#include <vector>
#include <functional>
#include <memory>
<p>class Publisher {
private:
struct CallbackWrapper {
std::weak_ptr<std::function<void(int)>> cb;
};
std::vector<CallbackWrapper> callbacks;</p><p>public:
std::shared_ptr<std::function<void(int)>>
subscribe(std::function<void(int)> func) {
auto shared_func = std::make_shared<std::function<void(int)>>(func);
callbacks.push_back({shared_func});
return shared_func; // 返回共享指针作为“订阅句柄”
}</p><pre class='brush:php;toolbar:false;'>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），若跨线程发布。基本上就这些。根据项目复杂度选择合适实现方式即可。
