责任链模式就是对一批请求进行判断，是自己责任范围内的就处理，不是自己责任范围内的就传递给下一个负责人；比如有三个项目经理，顺序是A->B->C，把所有的项目都先传递给A，A拿到所有的项目后，把属于自己负责的项目留下来，把剩下的传递给B，然后B把属于自己的留下来，把不属于自己的再传递给C;

1.请求者接口基类

#pragma once
#include <string>
using namespace std;
class Female
{
public:
	Female(void);
	virtual ~Female(void);
	virtual int getType() = 0;
	virtual string getRequest() = 0;
private:

};

Female::Female()
{
}

Female::~Female()
{
}

1.1具体的请求者

#pragma once
#include "Female.h"
class Women:public Female
{
public:
	
	Women(int type,string request);
	~Women(void);
	int getType();
	string getRequest();
private:
	int mType;
	string mRequest;
};

Women::Women(int type, string request)
{
	this->mType = type;
	switch (this->mType)
	{
		case 1:
			this->mRequest.append(request);
			break;
		case 2:
			this->mRequest.append(request);
			break;
		case 3:
			this->mRequest.append(request);
			break;
	default:
		break;
	}
}

Women::~Women(void)
{
}

int Women::getType()
{
	return this->mType;
}

string Women::getRequest()
{
	return mRequest;
}

2.处理者基类

#pragma once
#include "Female.h"
class Handler
{
public:
	Handler(int type);
	virtual ~Handler(void);
	void HandleRequest(Female* pFemale);
	void SetNextHandler(Handler* next);
	virtual void ResponseRequest(Female* pFemale) = 0;
private:
	int mType;
	Handler* mpNextHandler;
};

Handler::Handler(int type):mType(type)
{
	mpNextHandler = nullptr;
}

Handler::~Handler(void)
{
}

void Handler::HandleRequest(Female* pFemale)
{
	if (pFemale->getType() == this->mType)
	{
		this->ResponseRequest(pFemale);
	}
	else
	{
		if (this->mpNextHandler != nullptr)
		{
			this->mpNextHandler->HandleRequest(pFemale);
		}
	}
}

void Handler::SetNextHandler(Handler* next)
{
	this->mpNextHandler = next;
}

2.1. 具体的处理者1

#pragma once
#include "Handler.h"
#include <iostream>
class Father:public Handler
{
public:
	Father(void);
	~Father(void);
	void ResponseRequest(Female* pFemale);
private:

};

Father::Father(void):Handler(1)
{
}

Father::~Father(void)
{
}

void Father::ResponseRequest(Female* pFemale)
{
	cout << "女儿向父亲请示:" << pFemale->getRequest() << endl;
	cout << "父亲回答:我不同意" << endl;
}

2.2 具体的处理者2

#pragma once
#include "Handler.h"
#include <iostream>
class Husband :public Handler
{
public:
	Husband(void);
	~Husband(void);
	void ResponseRequest(Female* pFemale);
private:

};

Husband::Husband(void) :Handler(2)
{
}

Husband::~Husband(void)
{
}

void Husband::ResponseRequest(Female* pFemale)
{
	cout << "老婆向老公请示:" << pFemale->getRequest() << endl;
	cout << "老公回答:同意" << endl;
}

2.3 具体的处理者3

#pragma once
#include "Handler.h"
#include <iostream>
class Son :public Handler
{
public:
	Son(void);
	~Son(void);
	void ResponseRequest(Female* pFemale);
private:

};

Son::Son(void) :Handler(3)
{
}

Son::~Son(void)
{
}

void Son::ResponseRequest(Female* pFemale)
{
	cout << "母亲向儿子请示:" << pFemale->getRequest() << endl;
	cout << "儿子回答:同意" << endl;
}

3.主程序

// 责任链模式.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include "Father.h"
#include "Women.h"
#include "Handler.h"
#include "Husband.h"
#include "Son.h"
#include "Female.h"

int main()
{
    Female* pDaughter = new Women(1, "我要和男朋友出去旅游");
    Female* pWife = new Women(2,"我要买个新包包");
    Female* pMother = new Women(3, "我要去跳广场舞");

    Handler* pFather = new Father();
    Handler* pHusband = new Husband();
    Handler* pSon = new Son();

    pFather->SetNextHandler(pHusband);
    pHusband->SetNextHandler(pSon);

    //父亲->老公->儿子
    pFather->HandleRequest(pDaughter);
    pFather->HandleRequest(pWife);
    pFather->HandleRequest(pMother);

    delete pDaughter;
    delete pWife;
    delete pMother;
    delete pFather;
    delete pHusband;
    delete pSon;

    system("pause");
    return 0;
}

4.结果