c++责任链模式 --学习笔记

设计模式学习-责任链模式
1.责任链模式可以想象成一个链条，链条的每一段都对传入的信息进行处理。

使用例子：
1.多个判断检验，多个信息筛选
2.比如买东西，想买个10元以内的，可以找哥哥要钱，想买个20的，需要找爸爸要钱，想买个30的就需要找爷爷处理了。最后也可以返回是谁解决的问题，都有谁不能解决问题。

方式：两种方式，第一种，处理类自己传递请求

class AbstractHandler {//具体处理类的父类
public:
    virtual void jutihandle(int i);
    virtual ~AbstractHandler(){}

    void setNext(AbstractHandler* handle)
    {
        m_nexthandle = handle;
    }

protected:
    AbstractHandler* m_nexthandle;
};

class brotherhandle :public AbstractHandler {
public:
    void jutihandle(int i)
    {
        if (i <= 10)
        {
            std::cout << "brother handle" << std::endl;
        }
        if (m_nexthandle)
            m_nexthandle->jutihandle(i);
    }
};

class fatherhandle :public AbstractHandler {
public:
    void jutihandle(int i)
    {
        if (i > 10&&i<=20)
        {
            std::cout << "father handle" << std::endl;
        }
        if (m_nexthandle)
            m_nexthandle->jutihandle(i);
    }
};

class grandfatherHandle : public AbstractHandler {
public:
    void jutihandle(int i)
    {
        if (i> 20)
        {
            std::cout << "father handle" << std::endl;
        }
        if (m_nexthandle)
            m_nexthandle->jutihandle(i);
    }
};

class requestcls {
public:
    void request(int i, AbstractHandler* handle)
    {
        handle->jutihandle(i);
    }
};

int main()
{
    int i = 40;
    brotherhandle* brother = new brotherhandle();
    fatherhandle* father = new fatherhandle();
    grandfatherHandle* grandfather = new grandfatherHandle();
    requestcls cls;
    brother->setNext(father);//第一种方法初始化的时候太麻烦，但是可以传递当前执行的情况，联系上下文比较不错
    brother->setNext(grandfather);
    cls.request(i, brother);
    return 0;
}

第二种方法：统一调用责任链中的所有筛选验证

class AbstractHandler {//具体处理类的父类
public:
    virtual void jutihandle(int i);
    virtual ~AbstractHandler(){}
};

class brotherhandle :public AbstractHandler {
public:
    void jutihandle(int i)
    {
        if (i <= 10)
        {
            std::cout << "brother handle" << std::endl;
        }
    }
};

class fatherhandle :public AbstractHandler {
public:
    void jutihandle(int i)
    {
        if (i > 10&&i<=20)
        {
            std::cout << "father handle" << std::endl;
        }
    }
};

class grandfatherHandle : public AbstractHandler {
public:
    void jutihandle(int i)
    {
        if (i> 20)
        {
            std::cout << "father handle" << std::endl;
        }
    }
};

class listHandle {
public:
    listHandle()
    {
        m_listHandle.push_back(new brotherhandle());
        m_listHandle.push_back(new fatherhandle());
        m_listHandle.push_back(new grandfatherHandle());
    }

    void handleProcess(int i)//也可以设置已经验证成功就break,或者需要联系上下文
    {
        for (auto& it : m_listHandle)
        {
            it->jutihandle(i);
        }
    }

private:
    list<AbstractHandler*>m_listHandle;
};

int main()
{
    int i = 40;
    listHandle hand;
    hand.handleProcess(i);
    return 0;
}

第二种方式初始化的时候更少，封装性更好。