C++ 设计模式-观察者模式
参考网址:https://blog.csdn.net/wuzhekai1985/article/details/6674984
观察者模式
定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。它还有两个别名,依赖(Dependents),发布-订阅(Publish-Subsrcibe)。
基于C++继承方式实现
#include <iostream>
#include <string>
#include <list>
using namespace std;
//观察者
class Observer
{
public:
Observer() = default;
virtual ~Observer() = default;
virtual void Update() {}
};
//博客
class Blog
{
public:
Blog() = default;
virtual ~Blog() = default;
void Attach(Observer *observer) { m_observers.push_back(observer); } //添加观察者
void Remove(Observer *observer) { m_observers.remove(observer); } //移除观察者
void Notify() //通知观察者
{
auto iter = m_observers.begin();
for(; iter != m_observers.end(); iter++)
(*iter)->Update();
}
virtual void SetStatus(string s) { m_status = s; } //设置状态
virtual string GetStatus() { return m_status; } //获得状态
private:
list<Observer* > m_observers; //观察者链表
protected:
string m_status; //状态
};
//具体博客类
class BlogCSDN : public Blog
{
private:
string m_name; //博主名称
public:
explicit BlogCSDN(string name): m_name(std::move(name)) {}
~BlogCSDN() override = default;
void SetStatus(string s) override { m_status = "CSDN:" + m_name + s; } //具体设置状态信息
string GetStatus() override { return m_status; }
};
//具体观察者
class ObserverBlog : public Observer
{
private:
string m_name; //观察者名称
Blog *m_blog; //观察的博客,当然以链表形式更好,就可以观察多个博客
public:
ObserverBlog(string name,Blog *blog): m_name(std::move(name)), m_blog(blog) {}
~ObserverBlog() override = default;
void Update() override //获得更新状态
{
string status = m_blog->GetStatus();
cout<<m_name<<"-------"<<status<<endl;
}
};
int main(){
Blog *blog = new BlogCSDN("wangdaming:");
Observer *observer1 = new ObserverBlog("learn", blog);
blog->Attach(observer1);
blog->SetStatus("DesignMode");
blog->Notify();
blog->Remove(observer1);
delete blog;
delete observer1;
return 0;
}
基于C++11实现的观察者模式(std::weak_ptr std::shared_ptr)
优点:类能知道观察者列表中的对象是否有效
#include <iostream>
#include <string>
#include <list>
#include <memory>
using namespace std;
//观察者
class Observer
{
public:
Observer() = default;
virtual ~Observer() = default;
virtual void Update() {}
};
//博客
class Blog
{
public:
Blog() = default;
virtual ~Blog() = default;
void Attach(std::shared_ptr<Observer>&& observer) { m_observers.emplace_back(std::move(observer)); } //添加观察者
void Notify() {//通知观察者
auto iter = m_observers.begin();
for(; iter != m_observers.end();){
auto ptr = iter->lock();
if(!ptr){
std::cout<<"observer is not"<<std::endl;
iter = m_observers.erase(iter);
continue;
}else{
ptr->Update();
++iter;
}
}
}
virtual void SetStatus(string s) { m_status = s; } //设置状态
virtual string GetStatus() { return m_status; } //获得状态
private:
list<std::weak_ptr<Observer>> m_observers; //观察者链表
protected:
string m_status; //状态
};
//具体博客类
class BlogCSDN : public Blog
{
private:
string m_name; //博主名称
public:
explicit BlogCSDN(string name): m_name(std::move(name)) {}
~BlogCSDN() override = default;
void SetStatus(string s) override { m_status = "CSDN:" + m_name +":"+ s; } //具体设置状态信息
string GetStatus() override { return m_status; }
};
//具体观察者
class ObserverBlog : public Observer
{
private:
string m_name; //观察者名称
std::shared_ptr<Blog> m_blog; //观察的博客,当然以链表形式更好,就可以观察多个博客
public:
ObserverBlog(string name,std::shared_ptr<Blog> blog): m_name(std::move(name)), m_blog(std::move(blog)) {}
~ObserverBlog() override = default;
void Update() override //获得更新状态
{
string status = m_blog->GetStatus();
cout<<m_name<<"-------"<<status<<endl;
}
};
int main(){
std::shared_ptr<Blog> blog =make_shared<BlogCSDN>("wangdaming");
{
std::shared_ptr<Observer> observer1 = make_shared<ObserverBlog>("learn", blog);
blog->Attach(std::move(observer1));
blog->SetStatus("DesignMode");
blog->Notify();
}
blog->Notify();
blog->Notify();
return 0;
}
基于C++11实现的观察者模式(std::function)
#include <iostream>
#include <string>
#include <functional>
#include <map>
using namespace std;
class NonCopyable{
protected:
NonCopyable() = default;
virtual ~NonCopyable() = default;
public:
NonCopyable(const NonCopyable&) = delete; // 禁用复制构造
NonCopyable& operator = (const NonCopyable&) = delete; // 禁用赋值构造
};
template<typename Func>
class Events : NonCopyable{
public:
Events() = default;
~Events()override = default;
// 注册观察者,支持右值引用
int Connect(Func&& f){
return Assgin(f);
}
// 注册观察者
int Connect(const Func& f){
return Assgin(f);
}
//移除观察者
void Disconnect(int key){
m_connections.erase(key);
}
// 通知所有的观察者
template<typename... Args>
void Notify(Args&&... args){
for (auto& it: m_connections){
it.second(std::forward<Args>(args)...);
}
}
private:
// 保存观察者并分配观察者的编号
template<typename F>
int Assgin(F&& f){
int k=m_observerId++;
m_connections.emplace(k, std::forward<F>(f));
return k;
}
private:
int m_observerId=0; // 观察者对应的编号
std::map<int, Func> m_connections; // 观察者列表
};
struct stA{
int a, b;
void print(int a, int b) { cout<<"stA::print:" << a << ", " << b << endl; }
};
void print(int a, int b) { cout<<"print:" << a << ", " << b << endl; }
int main(){
Events<std::function<void(int,int)>> myevent;
auto key=myevent.Connect(print); // 以函数方式注册观察者
stA t;
auto lambdakey=myevent.Connect([&t](int a, int b){ std::cout<<"lambda"<<std::endl; t.a=a; t.b=b; });// lamda注册
// std::function注册
std::function<void(int,int)> f = std::bind(&stA::print, &t, std::placeholders::_1,std::placeholders::_2);
myevent.Connect(f);
int a=1,b=2;
myevent.Notify(a,b); // 广播所有观察者
myevent.Disconnect(key); // 移除观察者
return 0;
}