设计模式：责任链模式

也是数据结构模式的一种，处理了在软件构建过程中，一个请求可能被多个对象处理，但是每个请求在运行时只能有一个接受者的问题，实现了请求发送者和接收者的解耦。
将接受的对象链接成一条链，并让请求沿着这条链传递，直到达到请求的目的或者责任链遍历完成返回异常，使得多个对象都有机会能够处理请求。
到游戏开发中，比如策划出了个像方舟那样的关卡链，玩家需要从本章第一关闯关到最后一关，此时我们需要发送一个维护到每个关卡中，如果使用责任链设计模式，我们只需要将维护请求发送到责任链首部的那个关卡，每一个节点就都能够接收到维护请求并执行。

#pragma once
#include <iostream>
using namespace std;

enum request_mode {
	request_mode1,
	request_mode2,
	request_mode3
};

template<typename T>
class request {
public:
	string name;
	request_mode req_mode;
	request(string name, request_mode req_mode) :name(name), req_mode(req_mode) {}
	request_mode get_type() {
		return req_mode;
	}
	string get_name() {
		return name;
	}
};

template<typename T>
class checkpoint_base {
private:
	checkpoint_base<T>* next_check_point;
public:
	string name;
	checkpoint_base() { next_check_point = nullptr; }
	virtual bool check_if_handle(request<T>* req) = 0;//查看是否能够处理
	virtual void process(request<T>* req) = 0;//处理
	void send_to_next_check_point(request<T>* req) {
		if (next_check_point != nullptr) {
			next_check_point->handle(req);
		}
		else cout << "责任链已遍历完成，请求没能被处理" << endl;
	}
	void set_next_checkpoint(checkpoint_base<T>* Checkpoint) {
			next_check_point = Checkpoint;
	}
	void handle(request<T>* req) {
		if (check_if_handle(req)) {
			//cout << "sb" << endl;
			process(req);
		}
		else
			send_to_next_check_point(req);
	}
};

template<typename T>
class checkpoint_1 :public checkpoint_base<T> {
public:
	virtual bool check_if_handle(request<T>* req) {
		return req->get_type() == request_mode::request_mode1;
	}
	virtual void process(request<T>* req) {
		cout << req->get_name() << "请求被checkpoint_1处理了" << endl;
	}
};

template<typename T>
class checkpoint_2 :public checkpoint_base<T> {
public:
	virtual bool check_if_handle(request<T>* req) {
		return req->get_type() == request_mode::request_mode2;
	}
	virtual void process(request<T>* req) {
		cout << req->get_name() << "请求被checkpoint_2处理了" << endl;
	}
};

template<typename T>
class checkpoint_3 :public checkpoint_base<T> {
public:
	virtual bool check_if_handle(request<T>* req) {
		return req->get_type() == request_mode::request_mode3;
	}
	virtual void process(request<T>* req) {
		cout << req->get_name() << "请求被checkpoint_3处理了" << endl;
	}
};

测试接口

	//测试chain_of_responsibility
	cout << "测试chain_of_responsibility" << endl;
	auto check_point_1 = new checkpoint_1<bool>;
	auto check_point_2 = new checkpoint_2<bool>;
	auto check_point_3 = new checkpoint_3<bool>;

	check_point_1->set_next_checkpoint(check_point_2);
	check_point_2->set_next_checkpoint(check_point_3);
	request<bool>* req = new request<bool>("请求3.1", request_mode3);
	check_point_1->handle(req);