C++观察者模式：实现与应用详解

1. 观察者模式在C++中的核心价值

观察者模式是23种经典设计模式中最常用的行为型模式之一，特别适合处理对象间一对多的依赖关系。我在多个大型C++项目中实践发现，当某个对象状态改变需要自动通知其他对象时，观察者模式能显著降低模块间的耦合度。

举个例子，在游戏开发中，当玩家角色血量变化时，UI血条、成就系统、音效管理器都需要立即响应。如果采用硬编码调用，代码会变成一团乱麻。而用观察者模式，只需让这些模块注册为血量的观察者，任何变化都会自动触发通知链。

2. 模式实现的核心组件

2.1 基础接口设计

先定义两个核心接口类，这是模式的骨架：

cpp复制class IObserver {
public:
    virtual ~IObserver() = default;
    virtual void Update(const std::string& message) = 0;
};

class ISubject {
public:
    virtual ~ISubject() = default;
    virtual void Attach(IObserver* observer) = 0;
    virtual void Detach(IObserver* observer) = 0;
    virtual void Notify() = 0;
};

这里有几个关键设计点：

1. 使用纯虚接口确保多态性
2. 析构函数声明为virtual避免内存泄漏
3. Update方法传递string消息，实际项目可改用模板参数

2.2 具体主题实现

以游戏中的任务系统为例：

cpp复制class QuestSystem : public ISubject {
private:
    std::list<IObserver*> observers_;
    std::string questState_;
    
public:
    void SetState(const std::string& state) {
        questState_ = state;
        Notify();  // 状态变化时自动通知
    }
    
    void Attach(IObserver* observer) override {
        observers_.push_back(observer);
    }
    
    void Detach(IObserver* observer) override {
        observers_.remove(observer);
    }
    
    void Notify() override {
        for (auto* observer : observers_) {
            observer->Update(questState_);
        }
    }
};

注意：实际项目中建议改用智能指针管理观察者生命周期，避免野指针问题

3. 高级实现技巧

3.1 线程安全改造

在多人游戏服务器中，观察者模式需要线程安全：

cpp复制#include <mutex>

class ThreadSafeSubject : public ISubject {
    //...
    std::mutex mtx_;
    
    void Attach(IObserver* observer) override {
        std::lock_guard<std::mutex> lock(mtx_);
        observers_.push_back(observer);
    }
    
    // 其他方法也需要类似加锁
};

3.2 性能优化方案

当观察者数量庞大时（如MMO游戏中的玩家列表），可以采用：

1. 分组通知机制
2. 异步消息队列
3. 差分更新（只通知变化的部分）

cpp复制// 示例：使用条件变量实现异步通知
void NotifyAsync() {
    std::thread([this](){
        std::unique_lock<std::mutex> lock(mtx_);
        cv_.wait(lock, [this]{ return !pendingUpdates_.empty(); });
        
        auto updates = std::move(pendingUpdates_);
        lock.unlock();
        
        for (auto& [observer, msg] : updates) {
            observer->Update(msg);
        }
    }).detach();
}

4. 实际项目中的典型问题

4.1 循环引用问题

当观察者和主题相互持有时，可能导致内存泄漏：

cpp复制// 错误示例
class Player : public IObserver {
    QuestSystem* questSystem_;  // 强引用
};

// 解决方案：改用weak_ptr
std::weak_ptr<QuestSystem> questSystem_;

4.2 通知顺序控制

某些场景需要确保通知顺序（如UI元素更新）：

cpp复制void Notify() override {
    // 按优先级排序
    observers_.sort([](auto* a, auto* b){
        return a->GetPriority() > b->GetPriority(); 
    });
    
    // 依次通知
    for (auto* obs : observers_) {
        obs->Update(state_);
    }
}

5. 现代C++的改进实现

5.1 使用function和lambda

C++11后可以摆脱继承束缚：

cpp复制class EventDispatcher {
    std::unordered_map<std::string, std::vector<std::function<void()>>> listeners_;
    
public:
    void Subscribe(const std::string& event, std::function<void()> callback) {
        listeners_[event].push_back(callback);
    }
    
    void Dispatch(const std::string& event) {
        for (auto& cb : listeners_[event]) {
            cb();
        }
    }
};

5.2 信号槽系统示例

类似Qt的信号槽机制：

cpp复制template <typename... Args>
class Signal {
    std::vector<std::function<void(Args...)>> slots_;
    
public:
    void Connect(std::function<void(Args...)> slot) {
        slots_.push_back(slot);
    }
    
    void Emit(Args... args) {
        for (auto& slot : slots_) {
            slot(args...);
        }
    }
};

// 使用示例
Signal<int, std::string> onDamage;
onDamage.Connect([](int amount, std::string source){
    std::cout << "受到" << amount << "点伤害，来自" << source;
});

6. 性能对比测试

在10万次通知测试中，不同实现的性能表现：

实际选择时需要权衡可维护性和性能需求

7. 与其他模式的协作

观察者模式常与这些模式配合使用：

1. 中介者模式：通过中介对象管理观察关系
2. 单例模式：全局事件总线常用实现方式
3. 组合模式：形成树形观察结构

cpp复制// 全局事件总线示例
class EventBus {
private:
    static EventBus* instance_;
    // ...其他成员
    
public:
    static EventBus& Get() {
        if (!instance_) {
            instance_ = new EventBus();
        }
        return *instance_;
    }
    
    // 禁止拷贝等操作
    EventBus(const EventBus&) = delete;
    void operator=(const EventBus&) = delete;
};

8. 实际工程建议

1. 日志记录：在Notify中添加调试日志
2. 异常处理：确保某个观察者崩溃不影响整体
3. 性能分析：使用Profiler监控通知耗时

cpp复制void SafeNotify() {
    for (auto* observer : observers_) {
        try {
            observer->Update(state_);
        } catch (const std::exception& e) {
            logError("Observer failed: " + std::string(e.what()));
        }
    }
}

在大型项目中，我通常会建立一个专门的ObserverManager来集中管理所有观察关系，提供以下功能：

• 观察者生命周期跟踪
• 通知频率限制
• 跨线程派发
• 调试可视化工具

这种集中式管理虽然增加了些许复杂度，但在项目规模扩大后，能显著降低维护成本。特别是在需要热重载功能的系统中，可以安全地动态添加/移除观察者。