当前位置：首页 > article >正文

C++设计模式-观察者模式：从基本介绍，内部原理、应用场景、使用方法，常见问题和解决方案进行深度解析

article 2025/3/12 16:55:18

一、基本介绍

1.1 模式定义与核心思想

观察者模式（Observer Pattern）是一种行为型设计模式，它定义了对象间一对多的依赖关系。当被观察对象（Subject）状态改变时，所有依赖它的观察者（Observer）都会自动收到通知并更新。这种模式类似于报纸订阅机制——报社发布新刊时，所有订阅者都会收到最新报纸。

1.2 模式价值体现

解耦利器：将事件发布者与订阅者解耦，提升系统扩展性
动态响应：支持运行时动态添加/移除观察者
事件驱动：构建异步事件处理系统的核心模式
跨层通信：实现不同模块间的松耦合通信

该模式在Qt信号槽、MVC架构、游戏引擎等领域有广泛应用，是GUI编程的基石模式之一。

二、内部原理剖析

2.1 模式结构分解

核心组件：

Subject（主题接口）
提供观察者注册/注销方法（如attach()/detach()）
维护观察者容器（通常使用std::vector或std::list）
定义通知方法notify()
Observer（观察者接口）
声明更新接口（如update()方法）
定义事件响应逻辑的规范

2.2 消息传递机制

观察者模式中的推模式（Push Model）与拉模式（Pull Model）是两种不同的数据传递策略，它们的核心区别在于主题与观察者之间的数据交互方式：
推模式（Push）
主题主动将完整或部分数据推送给观察者，无论观察者是否需要。比如，天气预报系统推送完整的温度、湿度、风力数据给用户。

virtual void update(int temperature, int humidity) = 0;

拉模式（Pull）
主题仅通知观察者状态变化，观察者通过主题接口主动拉取所需数据。比如，股票交易系统通知用户行情变化，用户自行查询感兴趣的股票详情。

virtual void update(WeatherStation* station) {{
    int temp = station->getTemperature();
}}

两种模式的选择本质上是数据控制权的权衡：推模式将控制权交给主题，拉模式则交给观察者。实际开发中常采用混合模式：基础数据通过推送方式，复杂数据通过拉取获取。

三、典型应用场景

3.1 GUI事件处理

在Qt框架中，按钮点击事件监听是经典案例：

QPushButton* btn = new QPushButton("Submit");
QObject::connect(btn, &QPushButton::clicked, [](){ 
    qDebug() << "Button clicked!"; 
});[4]()

按钮作为被观察者，点击事件触发时通知所有连接的槽函数（观察者）。

3.2 实时数据监控系统

以股票行情监控系统架构作为示例：
[证券交易所] --> [行情服务器(Subject)]
[行情服务器] --> [交易终端(Observer)]
[行情服务器] --> [大屏显示器(Observer)]
当股票价格变动时，所有终端实时更新显示。

3.3 游戏开发中的事件系统

实现角色受伤通知机制：

class Character {
    std::vector<Observer*> effects; // 中毒、流血等状态观察者 
public:
    void takeDamage(int damage) {
        notify(); // 触发状态效果更新 
    }
};

四、实现方法与最佳实践

4.1 标准实现步骤

定义抽象接口

class Observer {
public:
    virtual ~Observer() = default;
    virtual void update(const std::string& msg) = 0;
};
 
class Subject {
public:
    virtual void attach(Observer* o) = 0;
    virtual void detach(Observer* o) = 0;
    virtual void notify() = 0;
};

实现具体主题

class NewsAgency : public Subject {
    std::vector<Observer*> readers;
    std::string latestNews;
public:
    void attach(Observer* o) override { 
        readers.push_back(o);  
    }
    void setNews(const std::string& news) {
        latestNews = news;
        notify();
    }
};

4.2 高级实现技巧

使用智能指针管理生命周期

std::vector<std::shared_ptr<Observer>> observers; // 自动内存管理 
 
void detach(std::weak_ptr<Observer> o) {
    auto it = std::find_if(observers.begin(),  observers.end(), 
        [&o](const auto& ptr){ return ptr == o.lock();  });
    if(it != observers.end())  observers.erase(it); 
}

线程安全实现

#include <mutex>
 
class ConcurrentSubject : public Subject {
    std::mutex mtx;
public:
    void attach(Observer* o) override {
        std::lock_guard<std::mutex> lock(mtx);
        observers.push_back(o); 
    }
    // 类似实现detach和notify...
};

五、常见问题与解决方案

5.1 内存泄漏风险

问题现象：观察者未及时注销导致内存无法释放
解决方案：
使用weak_ptr弱引用观察者
在析构函数中自动注销

~ConcreteObserver() {
    subject->detach(this);
}[3]()

5.2 性能瓶颈

问题场景：高频事件导致通知风暴
优化策略：

批量通知机制

void accumulateUpdates() {
    if(++updateCount > 100) {
        notify();
        updateCount = 0;
    }
}

异步通知队列

void asyncNotify() {
    std::thread([this]{ notify(); }).detach();
}

5.3 循环引用问题

典型案例：主题与观察者相互持有shared_ptr
解决方法：

将其中一个引用改为weak_ptr
使用非拥有型指针配合手动生命周期管理

class Observer {
    std::weak_ptr<Subject> subject; // 打破循环引用 
};

六、模式扩展与演进方向

6.1 事件总线模式

构建全局事件分发中心：

class EventBus {
    std::unordered_map<EventType, std::vector<Handler>> handlers;
public:
    void subscribe(EventType type, Handler h) {
        handlers[type].push_back(h);
    }
    void publish(Event e) {
        for(auto& h : handlers[e.type]) h(e);
    }
};

6.2 响应式编程扩展

实现类似RxJS的流处理：

observable<int> sensorData = createObservable();
sensorData.filter([](int  v){ return v > 50; })
         .subscribe([](int v){ alert("警告值:" + v); });

6.3 与其它模式结合

观察者+工厂模式

class ObserverFactory {
public:
    static std::unique_ptr<Observer> create(ObserverType type) {
        switch(type) {
            case Logger: return std::make_unique<LogObserver>();
            case Notifier: return std::make_unique<EmailObserver>();
        }
    }
};