Chain of Responsibility 模式（责任链模式）

职责链

使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。

动机

一个请求可能被多个对象处理，但是每个请求在运行时只能有一个接收者，如果显式指定，将必不可少地带来请求发送者与接收者的紧耦合。
职责链使请求的发送者不需要指定具体的接收者，让请求的接收者自己在运行时决定来处理请求，从而使两者解耦。

适用场景

一个请求有多个处理对象（处理者可以动态配置、处理者的顺序可以动态配置、请求不需要指定具体的处理者）

优点

1、降低耦合度，它将请求的发送者和请求的处理者解耦。
2、简化了对象，使得对象不需要知道链的结构。
3、增强给对象指派职责的灵活性。通过改变链内的成员或者调动它们的次序，允许动态地新增或者删除责任。
4、增加新的请求处理类很方便。

缺点

1、执行未处理：不能保证请求一定会被接收到。
2、执行路径长：系统性能将会受到一定影响，而且在进行调试代码时不太方便。
3、执行的死循环：建链不当导致环形链表，死循环。

结构图

代码实现

#pragma once

#include <iostream>

// -------------------责任链模式-----------------------
namespace ChainOfResposibilityPattern {
	enum class RequestType {
		REQ_HANDLER1,
		REQ_HANDLER2,
		REQ_HANDLER3
	};

	// 请求
	class CRequest {
	public:
		CRequest(const std::string& sDescription, const RequestType& requestType) : msDescription(sDescription), mRequestType(requestType) {}

		std::string msGetDescription() const { return msDescription; }
		RequestType meGetRequestType() const { return mRequestType; }

	private:
		std::string msDescription;
		RequestType mRequestType;
	};

	// ----------------------- 稳定  -----------------------
	// 处理者基类
	class CHandler {
	public:
		// 处理
		void mvHandler(const CRequest& request) {
			// 能处理
			if (mbCanHandleRequset(request)) {
				// 处理请求
				mvProcessRequest();
			}
			// 发送请求到下一个处理者
			else {
				mvSendRequestToNextHandler(request);
			}
		}

		// 设置下一个处理者
		void mvSetNextHandler(CHandler* opNextHandler) { mopNextHandler = opNextHandler; }

	protected:
		// 能否处理
		virtual bool mbCanHandleRequset(const CRequest& request) = 0;
		// 处理请求
		virtual void mvProcessRequest() = 0;

	private:
		// 发送请求到下一个处理者
		void mvSendRequestToNextHandler(const CRequest& request) {
			if (mopNextHandler != nullptr) {
				mopNextHandler->mvHandler(request);
			}
		}

	protected:
		CHandler* mopNextHandler = nullptr; // 下一个处理者
	};

	// ----------------------- 变化  -----------------------
	// 实际处理者1
	class CConcreteHandler1 : public CHandler {
	public:
		virtual bool mbCanHandleRequset(const CRequest& request) override {
			return request.meGetRequestType() == RequestType::REQ_HANDLER1;
		}
		virtual void mvProcessRequest() override {
			std::cout << "ConcreteHandler1 ProcessRequest..." << std::endl;
		}
	};
	// 实际处理者2
	class CConcreteHandler2 : public CHandler {
	public:
		virtual bool mbCanHandleRequset(const CRequest& request) override {
			return request.meGetRequestType() == RequestType::REQ_HANDLER2;
		}
		virtual void mvProcessRequest() override {
			std::cout << "ConcreteHandler2 ProcessRequest..." << std::endl;
		}
	};
	// 实际处理者3
	class CConcreteHandler3 : public CHandler {
	public:
		virtual bool mbCanHandleRequset(const CRequest& request) override {
			return request.meGetRequestType() == RequestType::REQ_HANDLER3;
		}
		virtual void mvProcessRequest() override {
			std::cout << "ConcreteHandler3 ProcessRequest..." << std::endl;
		}
	};

	void test() {
		CConcreteHandler1 ch1;
		CConcreteHandler2 ch2;
		CConcreteHandler3 ch3;

		ch1.mvSetNextHandler(&ch2);
		ch2.mvSetNextHandler(&ch3);

		CRequest rq("handler3 process request ...", RequestType::REQ_HANDLER3);
		ch1.mvHandler(rq);
	}
}