【设计模式：responsibility chain pattern】

最新推荐文章于 2024-06-13 20:29:08 发布

XNB's Not a Beginner

最新推荐文章于 2024-06-13 20:29:08 发布

阅读量317

点赞数 8

分类专栏：设计模式文章标签：设计模式算法责任链模式 c++ 数据结构

本文链接：https://blog.csdn.net/RFoer/article/details/135998871

版权

设计模式专栏收录该内容

24 篇文章 0 订阅

订阅专栏

#include <string>
#include <iostream>

enum request_type : int;
enum REQUEST{
	_1 = 1,
	_2 = 2,
	_3 = 3,
	_4 = 4
} REQUEST;

typedef struct request{
	::std::string _Msg;
	request_type _Type;
} request;

class ChainHandler{
protected:
	ChainHandler *nextHandler { nullptr };

public:
	ChainHandler( void ) = default;
	ChainHandler( ChainHandler *next )
		: nextHandler( next ) {}
	virtual ~ChainHandler( void ) {}
	void SetNextHandle( ChainHandler *next ){
		nextHandler = next;
	}
	virtual void tryHandleRequest( const request& req ) {
		if( canHandleRequest( req ) ) processRequest( req );
		else sendRequestToNextHandler( req );
	}
	virtual bool canHandleRequest( const request& req ) const = 0;
	virtual void processRequest( const request& req ){
		::std::cout << "reqeust descript:\n"
					<< "msg:\t" << req._Msg
					<< "\ntype:\t" << req._Type
					<< '\n';
	}
	void sendRequestToNextHandler( const request& req ){
		if( nextHandler )
			nextHandler->tryHandleRequest( req );
		else{
			ChainHandler::processRequest( req );
			puts("no handler to handle the request");
		}
	}
};

class ConcreteHandler_type_1 : public ChainHandler{
public:
	ConcreteHandler_type_1( void ) = default;
	ConcreteHandler_type_1( ChainHandler *next )
		: ChainHandler( next ) {}
	virtual bool canHandleRequest( const request& req ) const override{
		return req._Type == ( request_type )REQUEST::_1;
	}
	virtual void processRequest( const request& req ) override{
		ChainHandler::processRequest( req );
		puts("IS BEING PROCESSED BE HANDLER 1");
	}
};

class ConcreteHandler_type_2 : public ChainHandler{
public:
	ConcreteHandler_type_2( void ) = default;
	ConcreteHandler_type_2( ChainHandler *next )
		: ChainHandler( next ) {}
	virtual bool canHandleRequest( const request& req ) const override{
		return req._Type == ( request_type )REQUEST::_2;
	}
	virtual void processRequest( const request& req ) override{
		ChainHandler::processRequest( req );
		puts("IS BEING PROCESSED BE HANDLER 2");
	}
};

class ConcreteHandler_type_3 : public ChainHandler{
public:
	ConcreteHandler_type_3( void ) = default;
	ConcreteHandler_type_3( ChainHandler *next )
		: ChainHandler( next ) {}
	virtual bool canHandleRequest( const request& req ) const override{
		return req._Type == ( request_type )REQUEST::_3;
	}
	virtual void processRequest( const request& req ) override{
		ChainHandler::processRequest( req );
		puts("IS BEING PROCESSED BE HANDLER 3");
	}
};

int main( void ){
	ConcreteHandler_type_1 handler_3;
	ConcreteHandler_type_2 handler_2( &handler_3 );
	ConcreteHandler_type_3 firstHanlder( &handler_2 );
	request request_1{ "request 1", ( request_type )REQUEST::_1 };
	request request_2{ "request 2", ( request_type )REQUEST::_2 };
	request request_3{ "request 3", ( request_type )REQUEST::_3 };
	request request_4{ "request 4", ( request_type )REQUEST::_4 };
	firstHanlder.tryHandleRequest( request_3 );
	puts("----------------------------------");
	firstHanlder.tryHandleRequest( request_4 );
	puts("----------------------------------");
	firstHanlder.tryHandleRequest( request_2 );
	puts("----------------------------------");
	firstHanlder.tryHandleRequest( request_1 );
	return 0;
}