设计模式-行为模式-职责链模式

这个模式也叫责任链模式。这种模式解决的是一个请求可能由多个类处理的问题，可以处理的多个类可以按照优先级先后决定自己能否处理请求。

以下代码定义了可以处理请求的接收者。以处理整型数字为例，两个子类分别处理正数和负数。

#include 

using namespace std;

class Receiver
{
public:
    virtual ~Receiver(){}
    virtual bool Receive(int value) = 0;
};

class PositiveReceiver:public Receiver
{
private:
    Receiver* NextReceiver;
public:
    PositiveReceiver(Receiver* rcvr):NextReceiver(rcvr){}
    bool Receive(int value)
    {
        if (value > 0)
        {
            cout<<__PRETTY_FUNCTION__<Receive(value);
            }
        }
        return false;
    }
};

class NegativeReceiver:public Receiver
{
private:
    Receiver* NextReceiver;
public:
    NegativeReceiver(Receiver* rcvr):NextReceiver(rcvr){}
    bool Receive(int value)
    {
        if (value < 0)
        {
            cout<<__PRETTY_FUNCTION__<Receive(value);
            }
        }
        return false;
    }
};

以下代码定义了一个请求发送者。它可以发送一个处理数字的请求。

class Requester
{
private:
    Receiver* receiver;
public:
    Requester(Receiver* rcvr):receiver(rcvr){}
    void Request(int value)
    {
        cout<<__FUNCTION__<<" value="<Receive(value);
        cout<<__FUNCTION__<<" result="<

以下代码演示了职责链模式。首先建立负数处理对象，再用它建立正数处理对象，最后请求者将请求发给正数处理对象。正数处理对象会优先处理，遇到不大于0的数，就会将数字给下一个处理者——负数处理对象。
在这个处理链中有一个漏洞，就是数字0没人处理，这在实践中要注意避免。

int main(void){
    Receiver* NR = new NegativeReceiver(nullptr);
    Receiver* PR = new PositiveReceiver(NR);
    Requester R(PR);
    R.Request(1);
    R.Request(0);
    R.Request(-1);
    delete NR;
    delete PR;
    return 0;
}

输出

Request value=1
virtual bool PositiveReceiver::Receive(int)
Request result=1

Request value=0
Request result=0

Request value=-1
virtual bool NegativeReceiver::Receive(int)
Request result=1