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

模式

目录

• 模式
  • 模式定义
  • 模式动机
  • UML类图
  • 源码实现
  • 优点
  • 缺点

模式定义

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

模式动机

• 当客户提交一个请求时，请求是沿链传递直至有一个ConcreteHandler对象负责处理它。

UML类图

源码实现

• request.h

#include <string>

class Request
{
public:
    Request(std::string type, std::string content, int count);

    std::string Type();
    std::string Content();
    int Count();
private:
    std::string     m_Type;
    std::string     m_Content;
    int             m_Count;
};

• request.cpp

#include "request.h"

Request::Request(std::string type, std::string content, int count)
    :m_Type(type),m_Content(content),m_Count(count)
{

}

std::string Request::Type()
{
   return m_Type;
}

std::string Request::Content()
{
    return m_Content;
}

int Request::Count()
{
    return m_Count;
}

• manager.h

#include "request.h"

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

    virtual void DoRequest(Request& request);
    void SetLastLevel(Manager* manager);

protected:
    Manager*        m_Last;
};

• director.h

#include "manager.h"

class Director : public Manager
{
public:
    Director();
    void DoRequest(Request& request) override;
};

• director.cpp

#include "director.h"
#include <iostream>

Director::Director()
{

}

void Director::DoRequest(Request &request)
{
    if(request.Type() == "请假" && request.Count() < 11)
    {
        std::cout << "总监批准请假" << std::endl;
    }
    else if(request.Type() == "加薪" && request.Count() < 1000)
    {
        std::cout << "总监批准加薪" << std::endl;
    }
    else
    {
        if(m_Last)
            m_Last->DoRequest(request);
    }
}

• main.cpp

#include <iostream>
#include "managerp.h"
#include "director.h"
#include "generalmanagerp.h"
#include "request.h"

using namespace std;

int main()
{
    GeneralManagerP* gmp = new GeneralManagerP();
    Director* direcotr = new Director();
    ManagerP* mp = new ManagerP();

    direcotr->SetLastLevel(gmp);
    mp->SetLastLevel(direcotr);

    Request req1("请假", "小明要请假", 5);
    mp->DoRequest(req1);


    Request req2("请假", "小明要请假", 18);
    mp->DoRequest(req2);

    Request req3("加薪", "小红要请假", 500);
    mp->DoRequest(req3);

    Request req4("加薪", "小明要请假", 50000);
    mp->DoRequest(req4);
    return 0;
}

• 运行结果

经理批准

总经理批准请假

总监批准加薪

优点

模式的优点

• 接收者和发送者都没有对方的明确信息，且链中的对象自己也并不知道链的结构。结果是职责链可简化对象的互相连接，它们仅需保持一个指向其后继者的引用，而不需要保持它所有的候选接收者的引用。这也就大大降低了耦合度。
• 可以随时的增加或修改处理一个请求的结构。增强了给对象指派职责的灵活性。

缺点

模式的缺点

• 一个请求极有可能到了链的末端都得不到处理，或者因为没有正确配置而得不到处理。