职责链模式（C++实现）

（本博客旨在个人总结回顾）

1、详情：

职责链模式：使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

说明：

优点： 

①降低耦合度。它将请求的发送者和接收者解耦。

②简化了对象。使得对象不需要知道链的结构。

③增强给对象指派职责的灵活性。通过改变链内的成员或者调动它们的次序，允许动态地新增或者删除责任。

④增加新的请求处理类很方便。

缺点：

 ①不能保证请求一定被接收。

②系统性能将受到一定影响，而且在进行代码调试时不太方便，可能会造成循环调用。

③可能不容易观察运行时的特征，有碍于除错。

使用场景：

 ①有多个对象可以处理同一个请求，具体哪个对象处理该请求由运行时刻自动确定。

②在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。

③可动态指定一组对象处理请求。

2.1、UML类图：

 

2.2、例子源码

stdafx.h

// stdafx.h : 标准系统包含文件的包含文件，
// 或是经常使用但不常更改的
// 特定于项目的包含文件
//

#pragma once

#include "targetver.h"

#include <stdio.h>
#include <tchar.h>

#include <iostream>
using namespace std;

// TODO:  在此处引用程序需要的其他头文件

Handler.h

#pragma once

class Handler
{
public:
    Handler();
    virtual ~Handler();

public:
    void SetSuccessor(Handler* pHandler);
    virtual void HandleRequest(int nRequest) = 0;

protected:
    Handler* m_pSuccessor;
};

Handler.cpp

#include "stdafx.h"
#include "Handler.h"

Handler::Handler()
    : m_pSuccessor(NULL)
{
}

Handler::~Handler()
{
    if (NULL != m_pSuccessor)
    {
        delete m_pSuccessor;
        m_pSuccessor = NULL;
    }
}

void Handler::SetSuccessor(Handler* pHandler)
{
    if (NULL != m_pSuccessor)
    {
        delete m_pSuccessor;
        m_pSuccessor = NULL;
    }
    m_pSuccessor = pHandler;
}

HandlerX.h

#pragma once
#include "Handler.h"

class HandlerX :
    public Handler
{
public:
    HandlerX();
    ~HandlerX();

public:
    void HandleRequest(int nRequest);
};

HandlerX.cpp

#include "stdafx.h"
#include "HandlerX.h"

HandlerX::HandlerX()
{
}

HandlerX::~HandlerX()
{
}

void HandlerX::HandleRequest(int nRequest)
{
    if (nRequest >= 0 && nRequest <= 10)
    {
        cout << "解决者：HandlerX,请求:" << nRequest << endl;
    }
    else if (m_pSuccessor != NULL)
    {
        m_pSuccessor->HandleRequest(nRequest);
    }
}

HandlerY.h

#pragma once
#include "Handler.h"

class HandlerY :
    public Handler
{
public:
    HandlerY();
    ~HandlerY();

public:
    void HandleRequest(int nRequest);
};

HandlerY.cpp

#include "stdafx.h"
#include "HandlerY.h"

HandlerY::HandlerY()
{
}

HandlerY::~HandlerY()
{
}

void HandlerY::HandleRequest(int nRequest)
{
    if (nRequest >= 11 && nRequest <= 20)
    {
        cout << "解决者：HandlerY,请求:" << nRequest << endl;
    }
    else if (m_pSuccessor != NULL)
    {
        m_pSuccessor->HandleRequest(nRequest);
    }
}

HandlerZ.h

#pragma once
#include "Handler.h"

class HandlerZ :
    public Handler
{
public:
    HandlerZ();
    ~HandlerZ();

public:
    void HandleRequest(int nRequest);
};

HandlerZ.cpp

#include "stdafx.h"
#include "HandlerZ.h"

HandlerZ::HandlerZ()
{
}

HandlerZ::~HandlerZ()
{
}

void HandlerZ::HandleRequest(int nRequest)
{
    if (nRequest >= 21 && nRequest <= 30)
    {
        cout << "解决者：HandlerZ,请求:" << nRequest << endl;
    }
    else if (m_pSuccessor != NULL)
    {
        m_pSuccessor->HandleRequest(nRequest);
    }
}

调用代码

ChainOfResponsibilityPatternMemo.cpp

// ChainOfResponsibilityPatternMemo.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "HandlerX.h"
#include "HandlerY.h"
#include "HandlerZ.h"

int _tmain(int argc, _TCHAR* argv[])
{
    int arrayRequest[9] = {1, 2, 3, 11, 12, 13, 21, 22, 23};

    Handler* pHandler1 = new HandlerX();
    Handler* pHandler2 = new HandlerY();
    Handler* pHandler3 = new HandlerZ();
    pHandler1->SetSuccessor(pHandler2);
    pHandler2->SetSuccessor(pHandler3);

    for (int i = 0; i < 9; i++)
    {
        pHandler1->HandleRequest(arrayRequest[i]);
    }

    delete pHandler1;
    pHandler1 = NULL;

    system("pause");
	return 0;
}

2.3、运行结果：