設計模式C++學習筆記之十七（Chain of Responsibility責任鏈模式）

17.1.解釋

概念：使多個對象都有機會處理請求，從而避免請求的寄件者和接收者之間的耦合關係。將這些對象連成一條鏈，並沿著這條鏈傳遞該請求，直到有一個對象處理它為止。

main()，客戶

IWomen，發出要求者介面

CWomen，要求者實作類別

CHandler，處理請求抽象類別

CFather，處理請求實作類別，責任鏈之一

CHusband，處理請求實作類別，責任鏈之二

CSon，處理請求實作類別，責任鏈之三

說明：CHandler抽象類別負責彙總責任鏈之中的其它處理對象，用SetNext來建立這個責任鏈。HandleMessage在處理請求時，會判斷是否是自己要處理的請求，如果是則直接處理。如果不是，則尋找下一個責任鏈上的處理對象，找到了則由下一個處理。

//IWomen.h

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

//Women.h

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

//Women.cpp

#include "StdAfx.h"
#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.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;
};

//Handler.cpp

#include "StdAfx.h"
#include "Handler.h"
#include <iostream>
using std::cout;
using std::endl;
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.h

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

//Father.cpp

#include "StdAfx.h"
#include "Father.h"
#include <iostream>
using std::cout;
using std::endl;
CFather::CFather(void) : CHandler(1)
{
}
CFather::~CFather(void)
{
}
void CFather::Response( IWomen *pwomen )
{
    cout << "女兒向父親請示：" << endl;
    cout << pwomen->GetRequest().c_str() << endl;
    cout << "父親的回覆是：同意" << endl;
}

//Husband.h

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

//Husband.cpp

#include "StdAfx.h"
#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.h

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

//Son.cpp

#include "StdAfx.h"
#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 "stdafx.h"
#include "INormalWomen.h"
#include "NormalWomen.h"
#include "INormalHandler.h"
#include "NormalFather.h"
#include "NormalHusband.h"
#include "NormalSon.h"

#include "IWomen.h"
#include "Women.h"
#include "Handler.h"
#include "Father.h"
#include "Husband.h"
#include "Son.h"
#include <iostream>
using std::cout;
using std::endl;
void DoIt()
{
    cout << "----------原來的處理方式----------" << endl;
    //INormalWomen.h, NormalWomen.h, INormalHandler.h, NormalFather.h, NormalHusband.h, NormalSon.h
    INormalWomen *pwomen = new CNormalWomen(1, "我要出去逛街");
    INormalHandler *pfather = new CNormalFather();
    INormalHandler *phusband = new CNormalHusband();
    INormalHandler *pson = new CNormalSon();
    if (pwomen->GetType() == 1)
    {
        cout << "女兒向父親請示：" << endl;
        pfather->HandleMessage(pwomen);
    }
    else if (pwomen->GetType() == 2)
    {
        cout << "妻子向丈夫請示：" << endl;
        phusband->HandleMessage(pwomen);
    }
    else if (pwomen->GetType() == 3)
    {
        cout << "母親向兒子請示：" << endl;
        pson->HandleMessage(pwomen);
    }
    else
    {
        //什麼也不做
    }
    delete pwomen;
    delete pfather;
    delete phusband;
    delete pson;
}
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, "我要出去逛街");
    IWomen *pwomen2 = new CWomen(2, "我要出去吃飯");
    IWomen *pwomen3 = new CWomen(3, "我也要出去吃飯");
    IWomen *pwomen4 = new CWomen(4, "我也要出去逛街");

    CHandler *pfather = new CFather();
    CHandler *phusband = new CHusband();
    CHandler *pson = new CSon();

    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 _tmain(int argc, _TCHAR* argv[])
{
    //反面
    DoIt();
    //要實現邏輯判斷，即女性的請求先發送到父親類，父親類一看是自己要處理的，就回應進行處理。如果女兒已經出嫁了，那就把這個請求轉寄到女婿類來處理。依此類推，形成了一個責任鏈。
    DoNew();
    return 0;
}