目录
18. 职责链模式
职责链模式：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之前的耦合关系，将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。
职责链上的处理者负责处理请求，客户只需要将请求发送到职责链上即可，无需关心请求的处理细节和请求的传递，所有职责链将请求的发送者和请求的处理者解耦了。
/*
* 关键代码：Handler内指明其上级，handleRequest()里判断是否合适，不合适则传递给上级。
*/
#include <iostream>
using namespace std;
enum RequestLevel
{
Level_One = 0,
Level_Two,
Level_Three,
Level_Num
};
//抽象处理者（Handler）角色，提供职责链的统一接口。
class Leader
{
public:
Leader(Leader* leader):m_leader(leader){}
virtual ~Leader(){}
virtual void handleRequest(RequestLevel level) = 0;
protected:
Leader* m_leader;
};
//具体处理者（Concrete Handler）角色
class Monitor:public Leader //链扣1
{
public:
Monitor(Leader* leader):Leader(leader){}
void handleRequest(RequestLevel level)
{
if(level < Level_Two)
{
cout << "Mointor handle request : " << level << endl;
}
else
{
m_leader->handleRequest(level);
}
}
};
//具体处理者（Concrete Handler）角色
class Captain:public Leader //链扣2
{
public:
Captain(Leader* leader):Leader(leader){}
void handleRequest(RequestLevel level)
{
if(level < Level_Three)
{
cout << "Captain handle request : " << level << endl;
}
else
{
m_leader->handleRequest(level);
}
}
};
//具体处理者（Concrete Handler）角色
class General:public Leader //链扣3
{
public:
General(Leader* leader):Leader(leader){}
void handleRequest(RequestLevel level)
{
cout << "General handle request : " << level << endl;
}
};
int main()
{
Leader* general = new General(nullptr);
Leader* captain = new Captain(general);
Leader* monitor = new Monitor(captain);
monitor->handleRequest(Level_One);
delete monitor;
monitor = nullptr;
delete captain;
captain = nullptr;
delete general;
general = nullptr;
return 0;
}
18.1 实例2
使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。
其思想很简单，考虑员工要求加薪。
公司的管理者一共有三级，总经理、总监、经理，如果一个员工要求加薪，应该向主管的经理申请，如果加薪的数量在经理的职权内，那么经理可以直接批准，否则将申请上交给总监。总监的处理方式也一样，总经理可以处理所有请求。这就是典型的职责链模式，请求的处理形成了一条链，直到有一个对象处理请求。给出这个例子的UML图。
代码的实现比较简单，如下所示：
//抽象管理者
class Manager
{
protected:
Manager *m_manager;
string m_name;
public:
Manager(Manager *manager, string name):m_manager(manager), m_name(name){}
virtual void DealWithRequest(string name, int num) {}
};
//经理
class CommonManager: public Manager
{
public:
CommonManager(Manager *manager, string name):Manager(manager,name) {}
void DealWithRequest(string name, int num)
{
if(num < 500) //经理职权之内
{
cout<<"经理"<<m_name<<"批准"<<name<<"加薪"<<num<<"元"<<endl<<endl;
}
else
{
cout<<"经理"<<m_name<<"无法处理，交由总监处理"<<endl;
m_manager->DealWithRequest(name, num);
}
}
};
//总监
class Majordomo: public Manager
{
public:
Majordomo(Manager *manager, string name):Manager(manager,name) {}
void DealWithRequest(string name, int num)
{
if(num < 1000) //总监职权之内
{
cout<<"总监"<<m_name<<"批准"<<name<<"加薪"<<num<<"元"<<endl<<endl;
}
else
{
cout<<"总监"<<m_name<<"无法处理，交由总经理处理"<<endl;
m_manager->DealWithRequest(name, num);
}
}
};
//总经理
class GeneralManager: public Manager
{
public:
GeneralManager(Manager *manager, string name):Manager(manager,name) {}
void DealWithRequest(string name, int num) //总经理可以处理所有请求
{
cout<<"总经理"<<m_name<<"批准"<<name<<"加薪"<<num<<"元"<<endl<<endl;
}
};
// 客户调用方式为：
//测试案例
int main()
{
Manager *general = new GeneralManager(NULL, "A"); //设置上级，总经理没有上级
Manager *majordomo = new Majordomo(general, "B"); //设置上级
Manager *common = new CommonManager(majordomo, "C"); //设置上级
common->DealWithRequest("D",300); //员工D要求加薪
common->DealWithRequest("E", 600);
common->DealWithRequest("F", 1000);
delete common;
delete majordomo;
delete general;
return 0;
}
参考资料：https://blog.csdn.net/wuzhekai1985/article/details/6673892
参考资料：https://www.cnblogs.com/chengjundu/p/8473564.html
19. 观察者模式
观察者模式：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都要得到通知并自动更新。
观察者模式从根本上讲必须包含两个角色：观察者和被观察对象。
1. 被观察对象自身应该包含一个容器来存放观察者对象，当被观察者自身发生改变时通知容器内所有的观察者对象自动更新。
2. 观察者对象可以注册到被观察者的中，完成注册后可以检测被观察者的变化，接收被观察者的通知。当然观察者也可以被注销掉，停止对被观察者的监控。
/*
* 关键代码：在目标类中增加一个ArrayList来存放观察者们。
*/
#include <iostream>
#include <list>
#include <memory>
using namespace std;
class View;
//被观察者抽象类 数据模型
class DataModel
{
public:
virtual ~DataModel(){}
virtual void addView(View* view) = 0;
virtual void removeView(View* view) = 0;
virtual void notify() = 0; //通知函数
};
//观察者抽象类 视图
class View
{
public:
virtual ~View(){ cout << "~View()" << endl; }
virtual void update() = 0;
virtual void setViewName(const string& name) = 0;
virtual const string& name() = 0;
};
//具体的被观察类， 整数模型
class IntDataModel:public DataModel
{
public:
~IntDataModel()
{
m_pViewList.clear();
}
virtual void addView(View* view) override
{
shared_ptr<View> temp(view);
auto iter = find(m_pViewList.begin(), m_pViewList.end(), temp);
if(iter == m_pViewList.end())
{
m_pViewList.push_front(temp);
}
else
{
cout << "View already exists" << endl;
}
}
void removeView(View* view) override
{
auto iter = m_pViewList.begin();
for(; iter != m_pViewList.end(); iter++)
{
if((*iter).get() == view)
{
m_pViewList.erase(iter);
cout << "remove view" << endl;
return;
}
}
}
virtual void notify() override
{
auto iter = m_pViewList.begin();
for(; iter != m_pViewList.end(); iter++)
{
(*iter).get()->update();
}
}
private:
list<shared_ptr<View>> m_pViewList;
};
//具体的观察者类 表视图
class TableView : public View
{
public:
TableView() : m_name("unknow"){}
TableView(const string& name) : m_name(name){}
~TableView(){ cout << "~TableView(): " << m_name.data() << endl; }
void setViewName(const string& name)
{
m_name = name;
}
const string& name()
{
return m_name;
}
void update() override
{
cout << m_name.data() << " update" << endl;
}
private:
string m_name;
};
int main()
{
/*
* 这里需要补充说明的是在此示例代码中，View一旦被注册到DataModel类之后，DataModel解析时会自动解析掉
* 内部容器中存储的View对象，因此注册后的View对象不需要在手动去delete，再去delete View对象会出错。
*/
View* v1 = new TableView("TableView1");
View* v2 = new TableView("TableView2");
View* v3 = new TableView("TableView3");
View* v4 = new TableView("TableView4");
IntDataModel* model = new IntDataModel;
model->addView(v1);
model->addView(v2);
model->addView(v3);
model->addView(v4);
model->notify();
cout << "-------------\n" << endl;
model->removeView(v1);
model->notify();
delete model;
model = nullptr;
return 0;
}
19.1 示例2
定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。它还有两个别名，依赖(Dependents)，发布-订阅(Publish-Subsrcibe)。
可以举个博客订阅的例子，当博主发表新文章的时候，即博主状态发生了改变，那些订阅的读者就会收到通知，然后进行相应的动作，比如去看文章，或者收藏起来。博主与读者之间存在种一对多的依赖关系。下面给出相应的UML图设计。
可以看到博客类中有一个观察者链表（即订阅者），当博客的状态发生变化时，通过Notify成员函数通知所有的观察者，告诉他们博客的状态更新了。而观察者通过Update成员函数获取博客的状态信息。代码实现不难，下面给出C++的一种实现。
//观察者
class Observer
{
public:
Observer() {}
virtual ~Observer() {}
virtual void Update() {}
};
//博客
class Blog
{
public:
Blog() {}
virtual ~Blog() {}
void Attach(Observer *observer) { m_observers.push_back(observer); } //添加观察者
void Remove(Observer *observer) { m_observers.remove(observer); } //移除观察者
void Notify() //通知观察者
{
list<Observer*>::iterator 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:
BlogCSDN(string name): m_name(name) {}
~BlogCSDN() {}
void SetStatus(string s) { m_status = "CSDN通知 : " + m_name + s; } //具体设置状态信息
string GetStatus() { return m_status; }
};
//具体观察者
class ObserverBlog : public Observer
{
private:
string m_name; //观察者名称
Blog *m_blog; //观察的博客，当然以链表形式更好，就可以观察多个博客
public:
ObserverBlog(string name,Blog *blog): m_name(name), m_blog(blog) {}
~ObserverBlog() {}
void Update() //获得更新状态
{
string status = m_blog->GetStatus();
cout<<m_name<<"-------"<<status<<endl;
}
};
// 客户的使用方式：
//测试案例
int main()
{
Blog *blog = new BlogCSDN("wodehao0808");
Observer *observer1 = new ObserverBlog("niuniu", blog);
blog->Attach(observer1);
blog->SetStatus("发表渲染测试");
blog->Notify();
delete blog;
delete observer1;
return 0;
}
参考资料：https://blog.csdn.net/wuzhekai1985/article/details/6674984
参考资料：https://www.cnblogs.com/chengjundu/p/8473564.html
20. 状态模式
状态模式：允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。它有两种使用情况：
（1）一个对象的行为取决于它的状态, 并且它必须在运行时刻根据状态改变它的行为。
（2）一个操作中含有庞大的多分支的条件语句，且这些分支依赖于该对象的状态。
本文的例子为第一种情况，以战争为例，假设一场战争需经历四个阶段：前期、中期、后期、结束。当战争处于不同的阶段，战争的行为是不一样的，也就说战争的行为取决于所处的阶段，而且随着时间的推进是动态变化的。下面给出相应的UML图。
实现的代码比较简单，给出War类和State类，War类中含State对象（指针形式）。
class War;
class State
{
public:
virtual void Prophase() {}
virtual void Metaphase() {}
virtual void Anaphase() {}
virtual void End() {}
virtual void CurrentState(War *war) {}
};
//战争
class War
{
private:
State *m_state; //目前状态
int m_days; //战争持续时间
public:
War(State *state): m_state(state), m_days(0) {}
~War() { delete m_state; }
int GetDays() { return m_days; }
void SetDays(int days) { m_days = days; }
void SetState(State *state) { delete m_state; m_state = state; }
void GetState() { m_state->CurrentState(this); }
};
给出具体的状态类：
//战争结束
class EndState: public State
{
public:
void End(War *war) //结束阶段的具体行为
{
cout<<"战争结束"<<endl;
}
void CurrentState(War *war) { End(war); }
};
//后期
class AnaphaseState: public State
{
public:
void Anaphase(War *war) //后期的具体行为
{
if(war->GetDays() < 30)
cout<<"第"<<war->GetDays()<<"天：战争后期，双方拼死一搏"<<endl;
else
{
war->SetState(new EndState());
war->GetState();
}
}
void CurrentState(War *war) { Anaphase(war); }
};
//中期
class MetaphaseState: public State
{
public:
void Metaphase(War *war) //中期的具体行为
{
if(war->GetDays() < 20)
cout<<"第"<<war->GetDays()<<"天：战争中期，进入相持阶段，双发各有损耗"<<endl;
else
{
war->SetState(new AnaphaseState());
war->GetState();
}
}
void CurrentState(War *war) { Metaphase(war); }
};
//前期
class ProphaseState: public State
{
public:
void Prophase(War *war) //前期的具体行为
{
if(war->GetDays() < 10)
cout<<"第"<<war->GetDays()<<"天：战争初期，双方你来我往，互相试探对方"<<endl;
else
{
war->SetState(new MetaphaseState());
war->GetState();
}
}
void CurrentState(War *war) { Prophase(war); }
};
// 使用方式：
//测试案例
int main()
{
War *war = new War(new ProphaseState());
for(int i = 1; i < 40;i += 5)
{
war->SetDays(i);
war->GetState();
}
delete war;
return 0;
}
参考资料：https://blog.csdn.net/wuzhekai1985/article/details/6675799
9万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
