责任链模式

定义：使得多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系。

外部使用时将这些对象练成一条链，并沿着这条链传递该请求，直到有一个对象处理他为止

应用场景：类似审批请假流程

优点：降低耦合度，简化对象，增强给对象指派职责的灵活性

缺点：增加新的请求处理类很方便，但是不能保证你的请求一定会被接受

步骤：

1、定义抽象处理者，定义处理请求的接口，且内部含有指向本类的指针，提供get和set方法

set方法可以将处理者连接起来

2、继承实现具体的处理者

3、外部使用时需要先组装责任链

---

以请假为例，向提交给A处理，A无法处理则交给B，B无法处理则交给C处理

//1、抽象处理者
class Leader {
public:
	virtual ~Leader() = default;

	//3、提供setter和getter
	void setNext(Leader* p)
	{
		next = p;
	}
	Leader* getNext() const
	{
		return next;
	}

	//4、声明纯虚接口  处理请求
	virtual void handleRequest(int days) = 0;

private:

	//2、内部持有指向本类的指针
	Leader* next;
};

//具体的处理者1
class Handler1 :public Leader
{
public:

	//重写处理函数
	void handleRequest(int days) override
	{
		//请假天数小于3天，则同意请假
		if (days < 3)
		{
			cout << "1号处理者同意请假" << endl;
		}
		else
		{
			//如果请假天数超出了3天，就让下一个人处理者处理
			auto next = getNext();
			if (next)
			{
				//继续调用下一个处理者的handleRequest接口
				next->handleRequest(days);
			}
			else
			{
				cout << "请假天数太多" << endl;
			}
		}
	}

};

//具体的处理者2
class Handler2 :public Leader
{
public:

	//重写处理函数
	void handleRequest(int days) override
	{
		//请假天数小于5天，则同意请假
		if (days < 5)
		{
			cout << "2号处理者同意请假" << endl;
		}
		else
		{
			//如果请假天数超出了5天，就让下一个人处理者处理
			auto next = getNext();
			if (next)
			{
				next->handleRequest(days);
			}
			else
			{
				cout << "请假天数太多" << endl;
			}
		}
	}

};

//具体的处理者3
class Handler3 :public Leader
{
public:

	//重写处理函数
	void handleRequest(int days) override
	{
		//请假天数小于10天，则同意请假
		if (days <10 )
		{
			cout << "3号处理者同意请假" << endl;
		}
		else
		{
			//如果请假天数超出了10天，就让下一个人处理者处理
			auto next = getNext();
			if (next)
			{
				next->handleRequest(days);
			}
			else
			{
				cout << "请假天数太多" << endl;
			}
		}
	}

};


int main()
{
	//外部使用：
	Leader* handle1 = new Handler1();
	Leader* handle2 = new Handler2();
	Leader* handle3= new Handler3();

	//1、先组装责任链
	handle1->setNext(handle2);
	handle2->setNext(handle3);

	//2、然后调用请求处理接口，让请求从第一个处理者传递下去，直到被处理
	int day = 8;
	handle1->handleRequest(day);

	return 0;
}

总结：

责任链模式就是将这些处理者连成一条链。

链上的每个处理者都有一个成员变量来保存下一个处理者。

除了处理请求外， 处理者还负责沿着链传递请求， 请求会在链上移动， 直至所有处理者都有机会对其进行处理