P6级程序员
最近给团队里的程序员们分了个等级，模仿着**的那套模式，将我们团队里人分为P6/P7/P8/P9/P10。 来活儿的时候呢，就这样分配，根据难度初步估计，分配给对应的等级的程序员去做，难度等级7级就给P7,8级就给P8。
但是这样会有个什么问题呢？其实也没啥问题，就是这好像不需要用类，直接在场景main里面放一堆的if来判断就好了。 那如果分配到当前等级的人他不收呢？那就得移交到下一个等级去，这要是用ifelse来判断，可想而知代码将会有多么的拥挤。 而且将本不属于场景类的任务强加到场景类之中，似乎也不合情理。
所以，我们采用这样一个方法：创建一个责任类，将各级程序员按等级排序，当有任务来临时，依次向后，如果能接那就接了，轮到最后还没人接，那就退了，默认没人接。
这，就是责任链模式。
这个图是很简单的嘞：
代码实现
代码语言：javascript复制#include<iostream>
using namespace std;
//抽象任务类
class abstractRW {
public:
virtual int get_diff() = 0; //获取任务等级
virtual string get_RW() = 0; //获取任务内容
};
//具体任务类
class RW:public abstractRW{
protected:
int diff = 0;
string str = " ";
public:
RW(int diff, string str) {
this->diff = diff;
this->str = str;
}
int get_diff() { return this->diff; } //设置任务等级
string get_RW() { return this->str; } //设置任务内容
};
//任务分配类
class handle {
private:
int level = 5;
handle* nexthandle;
protected:
virtual void respon(abstractRW* rw) = 0;
public:
handle(int l) { this->level = l; }
void handleMessage(abstractRW* rw) {
if (rw->get_diff() == this->level)
this->respon(rw);
else
{
if (this->nexthandle != NULL)
this->nexthandle->handleMessage(rw);
else
cout << "没人接" << endl;
}
}
void setNext(handle* h) { this->nexthandle = h; }
};
class P6 :public handle {
public:
P6(int lev) :handle(lev){} //继承写法
void respon(abstractRW* rw) {
cout << rw->get_RW() << " P6接了" << endl;
}
};
class P7 :public handle {
public:
P7(int lev) :handle(lev) {}
void respon(abstractRW* rw) {
cout << rw->get_RW() << " P7接了" << endl;
}
};
class P8 :public handle {
public:
void respon(abstractRW* rw) {
cout << rw->get_RW() << " P8接了" << endl;
}
};
int main()
{
abstractRW* rw = new RW(7,"没事儿");
handle* h6 = new P6(6);
handle* h7 = new P7(7);
h6->setNext(h7);
h6->handleMessage(rw);
return 0;
}感悟
发现我上一篇写错了，毕竟上一篇是初学，然后刚刚遇到个bug，好烦，我就纳闷儿了，补全函数名就把括号也补上啊，乱七八糟，不想补全就别补啊，补一半，害我找了两个小时。
应用场景
优势
将请求和处理分开。 请求者可以不知道是谁处理了，处理者也不用知道请求者的全貌。 两者解耦，提高系统的灵活性。
劣势
有俩劣势非常明显：1、性能问题。2、调试不方便。
注意事项
链中节点数量需要控制，避免出现超长链的情况。可以通过设置阈值的方式来加以限制。
这个模式融合了模板方法模式，在应用之中要灵活。
