C++ 观察者模式实现详解与完整代码

核心接口定义

观察者模式通常包含两个核心角色：发布者和订阅者。为了实现松耦合，首先需要定义纯虚基类（抽象接口），让具体的实现类继承这些接口。

第1步：定义发布者接口

发布者负责管理订阅者列表，并提供注册、注销和通知功能。这是所有具体发布者必须实现的契约。

#ifndef __observerPatterns_publish_hpp__
#define __observerPatterns_publish_hpp__

#include "observerPatterns_subscribe.hpp"

class observerPatterns_publish
{
public:
    virtual void registerObjectSubscribe(observerPatterns_subscribe *ops) = 0;
    virtual void removeObjectSubscribe(observerPatterns_subscribe *ops) = 0;
    virtual void notifyObjectSubscribe() = 0;
};

#endif

第2步：定义订阅者接口

订阅者接口仅包含一个 update 方法，用于接收发布者发送的消息包。具体订阅逻辑在子类中实现。

#ifndef __observerPatterns_subscribe_hpp__
#define __observerPatterns_subscribe_hpp__

#include "observerPatterns_common.hpp"

class observerPatterns_subscribe
{
public:
    virtual void update(const observerPatterns_msgPackage &opmp) = 0;
};

#endif

公共数据结构

为了简化示例，定义一个简单的消息结构体用于传递数据。在实际项目中，可根据需求扩展为更复杂的 JSON 或 Protobuf 消息。

#ifndef __observerPatterns_common_hpp__
#define __observerPatterns_common_hpp__

#include 

struct observerPatterns_msgPackage
{
    std::string url;
    std::string msg;
};

typedef struct observerPatterns_msgPackage observerPatterns_msgPackage;

#endif

具体实现类

基于上述接口，实现具体的发布者和订阅者类。重点关注如何维护订阅关系以及如何处理内存生命周期。

第3步：实现发布者类

使用 std::unordered_set 存储订阅者指针，确保订阅者唯一且便于快速查找。构造函数需初始化相关成员变量。

#ifndef __observerPatterns_object_publish_hpp__
#define __observerPatterns_object_publish_hpp__

#include 
#include "observerPatterns_publish.hpp"

class observerPatterns_object_publish : public observerPatterns_publish
{
private:
    observerPatterns_msgPackage _opmp;
    std::unordered_set _subscribeObjectBucket;
public:
    observerPatterns_object_publish();
    ~observerPatterns_object_publish();
    void registerObjectSubscribe(observerPatterns_subscribe *ops);
    void removeObjectSubscribe(observerPatterns_subscribe *ops);
    void notifyObjectSubscribe();
    void setMsgPackage(const observerPatterns_msgPackage &opmp);
};

observerPatterns_object_publish::observerPatterns_object_publish()
{
}

observerPatterns_object_publish::~observerPatterns_object_publish()
{
}

void observerPatterns_object_publish::registerObjectSubscribe(observerPatterns_subscribe *ops)
{
    _subscribeObjectBucket.insert(ops);
}

void observerPatterns_object_publish::removeObjectSubscribe(observerPatterns_subscribe *ops)
{
    _subscribeObjectBucket.erase(ops);
}

void observerPatterns_object_publish::notifyObjectSubscribe()
{
    for (auto &&_sob : _subscribeObjectBucket)
        _sob->update(_opmp);
}

void observerPatterns_object_publish::setMsgPackage(const observerPatterns_msgPackage &opmp)
{
    _opmp = opmp;
    notifyObjectSubscribe();
}

#endif

第4步：实现订阅者类

订阅者在构造函数中自动注册自己到发布者，析构时自动注销，以简化生命周期管理。此处展示两种不同类型的订阅者，以体现多态能力。

#ifndef __observerPatterns_object_subscribe_hpp__
#define __observerPatterns_object_subscribe_hpp__

#include "observerPatterns_publish.hpp"
#include "observerPatterns_subscribe.hpp"

class observerPatterns_object_subscribe : public observerPatterns_subscribe
{
private:
    observerPatterns_msgPackage _opmp;
    observerPatterns_publish *_opb;
public:
    observerPatterns_object_subscribe(observerPatterns_publish *opb);
    ~observerPatterns_object_subscribe();
    void update(const observerPatterns_msgPackage &opmp);
};

observerPatterns_object_subscribe::observerPatterns_object_subscribe(observerPatterns_publish *opb)
    :_opb(opb)
{
    _opb->registerObjectSubscribe(this);
}

observerPatterns_object_subscribe::~observerPatterns_object_subscribe()
{
    _opb->removeObjectSubscribe(this);
}

void observerPatterns_object_subscribe::update(const observerPatterns_msgPackage &opmp)
{
    _opmp = opmp;
    printf("url:%s, msg:%s\n", _opmp.url.c_str(), _opmp.msg.c_str());
}

#endif

#ifndef __observerPatterns_object_subscribe2_hpp__
#define __observerPatterns_object_subscribe2_hpp__

#include "observerPatterns_publish.hpp"
#include "observerPatterns_subscribe.hpp"

class observerPatterns_object_subscribe2 : public observerPatterns_subscribe
{
private:
    observerPatterns_msgPackage _opmp;
    observerPatterns_publish *_opb;
public:
    observerPatterns_object_subscribe2(observerPatterns_publish *opb);
    ~observerPatterns_object_subscribe2();
    void update(const observerPatterns_msgPackage &opmp);
};

observerPatterns_object_subscribe2::observerPatterns_object_subscribe2(observerPatterns_publish *opb)
    :_opb(opb)
{
    _opb->registerObjectSubscribe(this);
}

observerPatterns_object_subscribe2::~observerPatterns_object_subscribe2()
{
    _opb->removeObjectSubscribe(this);
}

void observerPatterns_object_subscribe2::update(const observerPatterns_msgPackage &opmp)
{
    _opmp = opmp;
    printf("url:%s, msg:%s\n", _opmp.url.c_str(), _opmp.msg.c_str());
}

#endif

测试流程与运行结果

在主函数中，首先创建发布者实例，然后创建多个订阅者实例。注意：订阅者构造时将自动加入发布者的监听列表。

第5步：编写主函数测试

通过调用 setMsgPackage 触发消息广播。观察控制台输出，确认所有已注册的订阅者均收到了更新消息。

/************************************************************************
    > File Name: observerPatterns_main.cpp
    > Author: 
    > Mail: 
    > Created Time: 
************************************************************************/

#include "observerPatterns_common.hpp"
#include "observerPatterns_object_publish.hpp"
#include "observerPatterns_object_subscribe.hpp"
#include "observerPatterns_object_subscribe2.hpp"

using namespace std;

int main(int argc, char *argv[])
{
    observerPatterns_object_publish *opop = new observerPatterns_object_publish;
    
    observerPatterns_msgPackage opmp1, opmp2;
    opmp1.url = "www.aaa.com";
    opmp1.msg = "Hello!";
    opmp2.url = "www.xyzxyz.com";
    opmp2.msg = "Hello, observerPatterns!";
    
    // 创建订阅者，构造时自动注册
    observerPatterns_object_subscribe *oposa = new observerPatterns_object_subscribe(opop);
    observerPatterns_object_subscribe *oposb = new observerPatterns_object_subscribe(opop);
    observerPatterns_object_subscribe2 *oposc = new observerPatterns_object_subscribe2(opop);
    observerPatterns_object_subscribe2 *oposd = new observerPatterns_object_subscribe2(opop);

    // 发送第一条消息
    opop->setMsgPackage(opmp1);
    
    // 发送第二条消息
    opop->setMsgPackage(opmp2);
    
    // 清理资源
    delete oposa;
    delete opop;
    return 0;
}

运行上述代码后，控制台将打印四次输出，分别对应四个订阅者对两条消息的响应。这证明了观察者模式有效地实现了对象间的解耦与消息同步。

以上就是 C++ 观察者模式实现的详细内容，更多关于 C++ 设计模式的资料请关注本站其它相关文章！