1、定义

顾名思义，责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。

在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。

2、介绍

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

缺点： 1、不能保证请求一定被接收。 2、系统性能将受到一定影响，而且在进行代码调试时不太方便，可能会造成循环调用。 3、可能不容易观察运行时的特征，有碍于除错。

使用场景： 1、有多个对象可以处理同一个请求，具体哪个对象处理该请求由运行时刻自动确定。 2、在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。 3、可动态指定一组对象处理请求。

3、源码

类关系图：

思路：1、IWomen作为请求者接口类，具体请求和请求标志位（寻找负责类）由CWomen实现。2、CHandler作为负责类的接口，根据具体请求标志位，判断是否请求当前负责者类，如果不是请求当前负责者类，则去询问下一个。

3.1、头文件

IWomen.h

#pragma once
#include <iostream>
using namespace std;
class IWomen
{
public:
	IWomen(void)
	{
	}
	virtual ~IWomen(void)
	{
	}
	virtual int GetType() = 0;
	virtual string GetRequest() = 0;
};

Women.h

#pragma once
#include "iwomen.h"
class CWomen :
	public IWomen
{
public:
	CWomen(int _type, string _request);
	~CWomen(void);
	int GetType();
	string GetRequest();
private:
	int m_type;
	string m_request;
};

Handler.h

#pragma once
#include "IWomen.h"
class CHandler
{
public:
    CHandler(int _level);
    virtual ~CHandler(void);
    void HandleMessage(IWomen *pwomen);
    void SetNext(CHandler *phandler);
    virtual void Response(IWomen *pwomen) = 0;
private:
    int m_level;
    CHandler *m_pNextHandler;
};

Father.h

#pragma once
#include "handler.h"
#include "IWomen.h"
class CFather :
    public CHandler
{
public:
    CFather(void);
    ~CFather(void);
    void Response(IWomen *pwomen);
};

Husband.h

#pragma once
#include "handler.h"
#include "IWomen.h"
class CHusband :
	public CHandler
{
public:
	CHusband(void);
	~CHusband(void);
	void Response(IWomen *pwomen);
};

Son.h

#pragma once
#include "handler.h"
#include "IWomen.h"
class CSon :
	public CHandler
{
public:
	CSon(void);
	~CSon(void);
	void Response(IWomen *pwomen);
};

3.2、实现

Women.cpp

#include "Women.h"
CWomen::CWomen( int _type, string _request )
{
    this->m_type = _type;
    switch (this->m_type)
    {
    case 1:
        this->m_request.append("女儿的请求是：");
        this->m_request.append(_request);
        break;
    case 2:
        this->m_request.append("妻子的请求是：");
        this->m_request.append(_request);
        break;
    case 3:
        this->m_request.append("母亲的请求是：");
        this->m_request.append(_request);
        break;
    }
}
CWomen::~CWomen(void)
{
}
int CWomen::GetType()
{
    return m_type;
}
string CWomen::GetRequest()
{
    return m_request;
}

Handler.cpp

#include "Handler.h"
CHandler::CHandler(int _level) : m_level(_level)
{
	m_pNextHandler = NULL;
}
CHandler::~CHandler(void)
{
}
void CHandler::HandleMessage(IWomen *pwomen)
{
	if (pwomen->GetType() == this->m_level)
	{
		this->Response(pwomen);
	}
	else
	{
		if (this->m_pNextHandler != NULL)
			this->m_pNextHandler->HandleMessage(pwomen);
		else
			cout << "----------没地方请示了，不做处理！----------" << endl;
	}
}
void CHandler::SetNext(CHandler *phandler)
{
	m_pNextHandler = phandler;
}

Father.cpp

#include "Father.h"
CFather::CFather(void) : CHandler(1)
{
}
CFather::~CFather(void)
{
}
void CFather::Response(IWomen *pwomen)
{
	cout << "女儿向父亲请示：" << endl;
	cout << pwomen->GetRequest().c_str() << endl;
	cout << "父亲的答复是：同意" << endl;
}

Husband.cpp

#include "Husband.h"
#include <iostream>
using std::cout;
using std::endl;
CHusband::CHusband(void) : CHandler(2)
{
}
CHusband::~CHusband(void)
{
}
void CHusband::Response( IWomen *pwomen )
{
    cout << "妻子向丈夫请示：" << endl;
    cout << pwomen->GetRequest().c_str() << endl;
    cout << "丈夫的答复是：同意" << endl;
}

Son.cpp

#include "Son.h"
#include <iostream>
using std::cout;
using std::endl;
CSon::CSon(void) : CHandler(3)
{
}
CSon::~CSon(void)
{
}
void CSon::Response( IWomen *pwomen )
{
    cout << "母亲向儿子请示：" << endl;
    cout << pwomen->GetRequest().c_str() << endl;
    cout << "儿子的答复是：同意" << endl;
}

ChainofResponsibility.cpp

#include "IWomen.h"
#include "Women.h"
#include "Handler.h"
#include "Father.h"
#include "Husband.h"
#include "Son.h"
void DoNew()
{
	cout << "----------使用模式后的处理方式----------" << endl;
	//Handler.h, Handler.cpp, IWomen.h, Women.h, Women.cpp, Father.h, Father,cpp, Husband.h, Husband.cpp, Son.h, Son.cpp
	IWomen *pwomen1 = new CWomen(1, "我要出去逛街");//女儿请求，标志为1
	IWomen *pwomen2 = new CWomen(2, "我要出去吃饭");//妻子请求，标志为2
	IWomen *pwomen3 = new CWomen(3, "我也要出去吃饭");//母亲请求，标志为2
	IWomen *pwomen4 = new CWomen(4, "我也要出去逛街");

	CHandler *pfather = new CFather();//指向子类对象CFather,负责标志为1的请求
	CHandler *phusband = new CHusband();//指向子类对象CHusband,负责标志为2的请求
	CHandler *pson = new CSon();//指向子类对象CSon,负责标志为3的请求

    //指定自己的下一个请求者。
	pfather->SetNext(phusband);
	phusband->SetNext(pson);

	pfather->HandleMessage(pwomen1);
	pfather->HandleMessage(pwomen2);
	pfather->HandleMessage(pwomen3);
	pfather->HandleMessage(pwomen4);

	delete pfather;
	delete phusband;
	delete pson;
	delete pwomen1;
	delete pwomen2;
	delete pwomen3;
	delete pwomen4;
}
int main()
{
	//要实现逻辑判断，即女性的请求先发送到父亲类，父亲类一看是自己要处理的，就回应进行处理。如果女儿已经出嫁了，那就把这个请求转发到女婿类来处理。依此类推，形成了一个责任链。
	DoNew();
	return 0;
}

4、结果

参考文献：《菜鸟教程》 https://blog.csdn.net/phiall/article/details/52199659博客

设计模式之责任链模式（Chain of Responsibility）