责任链模式（Chain of Responsibility)

背景
在软件构建过程中，一个请求可能被多个对象处理，但是每个请求在运行时只能有一个接收者，如果显示指定，将必不可少的带来请求发送者与接收者的紧耦合。如何使得请求的发送者不需要指定具体的接收者？让请求的接收者自己在运行时决定来处理请求，从而使得两者解耦。
解决方法
让多个对象都有机会处理请求，从而避免请求的发送者与接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，知道有一个对象处理它为止。
适用于
责任链模式适用于“一个请求可能有多个接收者，但是最后真正的接收者只有一个”，这时候请求的发送者与接收者的耦合可能出现“变化脆弱”的症状，责任链的目的将二者解耦，从而更好地应对变化。如果请求传递到责任链末尾仍得不到处理，应该有一个合理的缺省机制。这也是每个接收对象的责任，不是发送请求的对象的责任。
优点
应用了责任链模式以后，对象的职责分派将更具有灵活性，我们可以在运行时动态添加、修改请求的处理职责。
代码说明
ConcreteHandleA的对象和handlerA拥有一个后继ConcreteHandleB的对象 handlerB,当一个请求到来时
候，handlerA 检查看自己有后继，于是handlerA 直接将请求传递给其后继 handlerB进行处理，handlerB因为没有后继，当请求到来时候，就只有自己提供响应了。
代码实现

//Handler.h
#pragma once
class Handler {
public:
	virtual ~Handler();
	virtual void HandlerRequest() = 0;
	void SetSuccess(Handler* success);
	Handler* GetSuccess();

protected:
	Handler();
	Handler(Handler* success);
private:
	Handler* m_success;
};
class ConcreteHandlerA :public Handler {
public:
	ConcreteHandlerA();
	ConcreteHandlerA(Handler* success);
	void HandlerRequest();
	~ConcreteHandlerA();
};
class ConcreteHandlerB :public Handler {
public:
	ConcreteHandlerB();
	ConcreteHandlerB(Handler* success);
	void HandlerRequest();
	~ConcreteHandlerB();
};
//Handler.cpp
# include"Handler.h"
#include<iostream>
using namespace std;
Handler::Handler() {
	m_success = 0;
}
Handler::Handler(Handler* success) {
	m_success = success;
}
void Handler::SetSuccess(Handler* success) {
	m_success = success;
}
Handler* Handler::GetSuccess() {
	return m_success;
}
Handler::~Handler() {
	delete m_success;
}
ConcreteHandlerA::ConcreteHandlerA() {

}
ConcreteHandlerA::ConcreteHandlerA(Handler* success) :Handler(success) {

}
void ConcreteHandlerA::HandlerRequest() {
	if (this->GetSuccess() != 0) {
		cout << "ConcreteHandlerA会把后续处理权交给其他处理" << endl;
		this->GetSuccess()->HandlerRequest();
	}
	else {
		cout << "ConcreteHandlerA没有后继，自己处理" << endl;
	}
}
ConcreteHandlerA::~ConcreteHandlerA() {

}
ConcreteHandlerB::ConcreteHandlerB() {

}
ConcreteHandlerB::ConcreteHandlerB(Handler* success) :Handler(success) {

}
void ConcreteHandlerB::HandlerRequest() {
	if (this->GetSuccess() != 0) {
		cout << "ConcreteHandlerB会把后续处理权交给其他处理" << endl;
		this->GetSuccess()->HandlerRequest();
	}
	else {
		cout << "ConcreteHandlerB没有后继，自己处理" << endl;
	}
}
ConcreteHandlerB::~ConcreteHandlerB() {

}
//Main.cpp
#include"Handler.h"
#include<iostream>
using namespace std;
int main() {
	Handler* handlerA = new ConcreteHandlerA();
	Handler* handlerB = new ConcreteHandlerB();
	handlerA->SetSuccess(handlerB);
	handlerA->HandlerRequest();
	return 0;
}

运行结果