我与C++设计模式（二十）——职责链模式

过了visitor模式，后面的模式就没有那么险山恶水了，不是说后面的简单，是之前的那些总有些听得太多却一直空洞不懂，一直以来都是不明觉厉的，后面的模式全当新玩意儿，反而不怕了，也可能是没来得及怕，容不得我不明觉厉。

扯了，chain of responsibility模式起因是从MFC的例子开始的，对于MFC的消息响应机制是VC的入门课，从一个消息到达，经过层层传递决定处理者的过程就是一条职责链，UML图如下：

Handler是接口，其子类接到请求后可以处理，也可以“扔锅”。每个concreteHandler都会有一个“接锅人”成员属性，在自己无法处理的时候，可以对其扔锅。

代码如下：

#ifndef _HANDLE_H__
#define _HANDLE_H__

class handler
{
        public:
                virtual ~handler();
                virtual void handle_request() = 0;
                virtual void set_successor(handler *);
                virtual handler *get_successor();

        protected:
                handler();
                handler(handler *);

        private:
                handler *_p_successor; //接锅人
};

class concrete_handler_A:public handler
{
        public:
                concrete_handler_A();
                concrete_handler_A(handler *);
                ~concrete_handler_A();
                void handle_request();
};

class concrete_handler_B:public handler
{
        public:
                concrete_handler_B();
                concrete_handler_B(handler *);
                ~concrete_handler_B();
                void handle_request();
};

#endif

//handler.cpp

#include "handler.h"
#include <iostream>
using namespace std;

handler::handler()
        :_p_successor(0)
{
}

handler::handler(handler *p_succ)
        :_p_successor(p_succ)
{
}

handler::~handler()
{
}

void handler::set_successor(handler *p_succ)
{
        _p_successor = p_succ;
}

handler *handler::get_successor()
{
        return _p_successor;
}

//--------------A--------------
concrete_handler_A::concrete_handler_A()
{
}

concrete_handler_A::concrete_handler_A(handler *p_succ)
        :handler(p_succ)
{
}

concrete_handler_A::~concrete_handler_A()
{
}

void concrete_handler_A::handle_request()
{
        if (get_successor() != 0)
        {
                cout<<"A: SUCCESSOR DOING"<<endl;
                get_successor()->handle_request();
        }
        else
        {
                cout<<"A: I'M THE LAST ONE"<<endl;
                cout<<"A: I WILL DEAL WITH IT"<<endl;
        }
}

//--------------B---------------
concrete_handler_B::concrete_handler_B()
{
}

concrete_handler_B::concrete_handler_B(handler *p_succ)
        :handler(p_succ)
{
}

concrete_handler_B::~concrete_handler_B()
{
}

void concrete_handler_B::handle_request()
{
        if (get_successor() != 0)
        {
                cout<<"B: SUCCESSOR DOING"<<endl;
                get_successor()->handle_request();
        }
        else
        {
                cout<<"B: I'M THE LAST ONE"<<endl;
                cout<<"B: I WILL DEAL WITH IT"<<endl;
        }
}

//main.cpp

#include "handler.h"

int main(int argc,char **argv)
{
        handler *p_h1 = new concrete_handler_A();
        handler *p_h2 = new concrete_handler_B();

        p_h1->set_successor(p_h2);

        p_h1->handle_request();

        return 0;
}

输出结果：

$ ./handler.exe
A: SUCCESSOR DOING
B: I'M THE LAST ONE
B: I WILL DEAL WITH IT