C++ 设计模式——职责链模式

于 2024-08-31 11:06:55 发布
阅读量528 收藏 6
点赞数 25
分类专栏： # C++ 设计模式 文章标签： c++ 设计模式 责任链模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_68194402/article/details/141749695
版权

目录

C++ 设计模式——职责链模式

职责链(Chain Of Responsibility)模式也叫责任链模式，是一种行为型模式，用于将一个请求传递给一个链中的若干对象，哪个对象适合处理这个请求就让哪个对象来处理。职责链看起来与传统数据结构中的“链表”非常类似。

引人“职责链”设计模式的定义(实现意图)：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链(构成对象链)，并沿着这条链传递该请求，直到有一个对象处理它为止。

1. 主要组成成分

  1. 处理器接口（Handler Interface）：定义了一个处理请求的接口，通常包含一个方法用于接收或处理请求。这个接口不确定请求的具体处理者。
  2. 具体处理器（Concrete Handlers）：实现处理器接口的类。每个处理器会对请求做出处理或者将请求传递给链中的下一个处理者。具体处理器决定了处理请求的条件和方式。
  3. 请求类（Request）：通常是包含多个属性的类，这些属性决定了哪个具体处理器应该处理该请求。
  4. 客户端（Client）：负责创建处理链，并向链的第一个处理器发送请求。客户端不关心请求如何以及由谁处理，这样做实现了发送者和接收者之间的解耦。

2. 逐步构建职责链模式

以下示例展示了如何实现一个用于处理加薪请求的职责链模式。此示例包含三个不同级别的审批者：部门经理、技术总监和总经理，各自能够处理特定范围的加薪请求。以下是构建职责链模式的详细步骤：

步骤1：定义处理者接口

已定义 RaiseRequest 类封装了加薪请求，其中包括员工姓名和加薪金额。

//加薪请求类
class RaiseRequest
{
public:
    //构造函数
    RaiseRequest(const string& sname, int salfigure) :m_sname(sname), m_isalfigure(salfigure) {}

    //获取请求加薪的人员名字
    const string& getName() const
    {
        return m_sname;
    }
    //获取请求加薪的数字
    int getSalFigure() const
    {
        return m_isalfigure;
    }

private:
    string m_sname;      //请求加薪的人员名字
    int    m_isalfigure; //请求加薪的数字
};
步骤2：定义抽象处理者

定义了一个名为 ParSalApprover 的抽象基类，其中包含一个处理请求的纯虚函数 processRequest 和一个函数 setNextChain 用于设置链中的下一个处理者。

//薪水审批者父类
class ParSalApprover
{
public:
    ParSalApprover() :m_nextChain(nullptr) {}
    virtual ~ParSalApprover() {} //做父类时析构函数应该为虚函数

    //设置指向的职责链中的下个审批者
    void setNextChain(ParSalApprover* next)
    {
        m_nextChain = next;
    }

    //处理加薪请求
    virtual void processRequest(const RaiseRequest& req) = 0;

protected:
    //找链中的下个对象并把请求投递给下个链中的对象
    void sendRequestToNextHandler(const RaiseRequest& req)
    {
        //找链中的下个对象
        if (m_nextChain != nullptr)
        {
            //把请求投递给链中的下个对象
            m_nextChain->processRequest(req);
        }
        else
        {
            //没找到链中的下个对象，程序流程执行这里似乎不应该
            cout << req.getName() << "的加薪要求为：" << req.getSalFigure() << "元，但无人能够审批！" << endl;
        }
    }

private:
    ParSalApprover* m_nextChain; //指向下一个审批者（对象）的多态指针（指向自身类型），每个都指向下一个，就会构成一个职责链（链表）
};
步骤3: 创建具体处理者

创建了三个具体处理者：depManager_SA, CTO_SA, 和 genManager_SA，每个类根据其规则处理请求。

//部门经理子类
class depManager_SA :public ParSalApprover
{
public:
    //处理加薪请求
    virtual void processRequest(const RaiseRequest& req)
    {
        int salfigure = req.getSalFigure();
        if (salfigure <= 1000)
        {
            //如果自己能处理，则自己处理
            cout << req.getName() << "的加薪要求为：" << salfigure << "元，部门经理审批通过！" << endl;
        }
        else
        {
            //自己不能处理，尝试找链中的下个对象来处理
            sendRequestToNextHandler(req);
        }
    }
};

//技术总监子类
class CTO_SA :public ParSalApprover
{
    //处理加薪请求
    virtual void processRequest(const RaiseRequest& req)
    {
        int salfigure = req.getSalFigure();
        if (salfigure > 1000 && salfigure <= 5000)
        {
            //如果自己能处理，则自己处理
            cout << req.getName() << "的加薪要求为：" << salfigure << "元，技术总监审批通过！" << endl;
        }
        else
        {
            sendRequestToNextHandler(req);//自己不能处理，尝试找链中的下个对象来处理
        }
    }
};

//总经理子类
class genManager_SA :public ParSalApprover
{
public:
    //处理加薪请求
    virtual void processRequest(const RaiseRequest& req)
    {
        int salfigure = req.getSalFigure();
        if (salfigure > 5000)
        {
            //如果自己能处理，则自己处理
            cout << req.getName() << "的加薪要求为：" << salfigure << "元，总经理审批通过！" << endl;
        }
        else
        {
            sendRequestToNextHandler(req);//自己不能处理，尝试找链中的下个对象来处理
        }
    }
};
步骤4: 配置职责链

在主函数中，创建处理者对象，并按逻辑顺序将它们连接起来形成一个链。

int main()
{
    //(1)创建出职责链中包含的各个对象（部门经理、技术总监、总经理）
    ParSalApprover* pzzlinkobj1 = new depManager_SA();
    ParSalApprover* pzzlinkobj2 = new CTO_SA();
    ParSalApprover* pzzlinkobj3 = new genManager_SA();
    //(2)将这些对象串在一起构成职责链（链表），现在职责链中pzzlinkobj1排在最前面，pzzlinkobj3排在最后面
    pzzlinkobj1->setNextChain(pzzlinkobj2);
    pzzlinkobj2->setNextChain(pzzlinkobj3);
    pzzlinkobj3->setNextChain(nullptr); //可以不写此行，因为ParSalApprover构造函数中设置了m_nextChain为nullptr

    //(3)创建几位员工关于加薪的请求（对象）
    RaiseRequest emp1Req("张三", 15000);//张三要求加薪1.5万
    RaiseRequest emp2Req("李四", 3500);//李四要求加薪3千5
    RaiseRequest emp3Req("王二", 800);//王二要求加薪8百
    //看看每位员工的加薪请求由职责链中的哪个对象（部门经理、技术总监、总经理）来处理，从职责链中排在最前面的接收者（pzzlinkobj1）开始
    pzzlinkobj1->processRequest(emp1Req);
    pzzlinkobj1->processRequest(emp2Req);
    pzzlinkobj1->processRequest(emp3Req);

    //(4)释放资源
    delete pzzlinkobj1;
    delete pzzlinkobj2;
    delete pzzlinkobj3;

    return 0;
}

3. 备忘录模式 UML 图

职责链模式 UML 图

UML 图解析

职责链模式的 UML 图中包含3种角色：

  1. Handler (处理者):
    • 作用：定义处理请求的接口（通常为 processRequest），同时也记录了链中下一个处理者的引用（在本例中使用 m_nextChain 来记录）。
    • 实现：在示例中，ParSalApprover 类扮演此角色，提供了设置下一个处理者和处理请求的基本框架。
  2. ConcreteHandler (具体处理者):
    • 作用：实现具体请求的处理逻辑。如果当前处理者无法完全处理请求，则将请求传递给链中的下一个处理者（后继者）。
    • 实现：在示例中，depManager_SA、CTO_SA 和 genManager_SA 类是具体处理者。每个类都有条件判断是否能处理请求，不能处理时将请求传递给链上的下一个处理者。
  3. Client (请求者/客户端):
    • 作用：向职责链上的具体处理者对象提交处理请求。客户端负责初始化处理链并触发请求处理过程。
    • 实现：在示例中，主函数 main 执行了客户端的角色。除了提交处理请求，它还负责创建职责链对象并搭建职责链。这部分通常是由客户端完成，因为职责链的结构和顺序可能根据不同的业务场景需要不同的配置。

4. 单纯与非单纯的职责链模式

在设计模式中，职责链模式可以分为两种形式：单纯的职责链模式和非单纯的职责链模式。这两种形式主要区别在于请求在链中的传递方式和处理者的责任范围。非单纯的职责链模式中允许一个请求被某个接收者处理后继续沿着职责链传递，其他处理者仍有机会继续处理该请求，这样的职责链往往也被称为功能链，即便一个请求未被任何处理者对象处理，在非单纯的职责链模式中也是允许的。功能链一般用于权限的多次多重校验、数据的多重检查和过滤等场合。

下面给出这个敏感词过滤器非单纯职责链模式范例(参照前面的范例书写即可)。该过滤器能够把聊天内容中涉及性、脏话、政治内容的关键词寻找出来并用一些其他符号来代替。首先创建敏感词过滤器父类，代码如下:

4.1 敏感词过滤器父类

定义一个抽象基类，其中包含将请求传递给链中下一个处理者的方法。

//敏感词过滤器父类
class ParWordFilter
{
public:
    ParWordFilter() :m_nextChain(nullptr) {}
    virtual ~ParWordFilter() {} //做父类时析构函数应该为虚函数

    //设置指向的职责链中的下个过滤器
    void setNextChain(ParWordFilter* next)
    {
        m_nextChain = next;
    }

    //处理敏感词过滤请求
    virtual string processRequest(string strWord) = 0;

protected:
    //找链中的下个对象并把请求投递给下个链中的对象
    string sendRequestToNextHandler(string strWord)
    {
        //找链中的下个对象
        if (m_nextChain != nullptr)
        {
            //把请求投递给链中的下个对象
            return m_nextChain->processRequest(strWord);
        }
        return strWord;
    }
private:
    ParWordFilter* m_nextChain;
};
4.2 具体过滤器实现

接着，创建敏感词过滤器子类共3个，分别用于过滤性、脏话、政治内容，代码如下：

//性敏感词过滤器子类
class SexyWordFilter :public ParWordFilter
{
public:
    virtual string processRequest(string strWord)
    {
        cout << "通过与词库比对，在strWord中查找\"性\"敏感词并用XXX来替换!" << endl;
        strWord += "XXX"; //测试代码，具体的实现逻辑略......
        return sendRequestToNextHandler(strWord);
    }
};

//脏话词过滤器子类
class DirtyWordFilter :public ParWordFilter
{
public:
    virtual string processRequest(string strWord)
    {
        cout << "通过与词库比对，在strWord中查找\"脏话\"敏感词并用YYY来替换!" << endl;
        strWord += "YYY";
        return sendRequestToNextHandler(strWord);
    }
};

//政治敏感词过滤器子类
class PoliticsWordFilter :public ParWordFilter
{
public:
    virtual string processRequest(string strWord)
    {
        cout << "通过与词库比对，在strWord中查找\"政治\"敏感词并用ZZZ来替换!" << endl;
        strWord += "ZZZ";
        return sendRequestToNextHandler(strWord);
    }
};
4.3 主函数

在主函数中创建和配置职责链。

int main()
{  
    //(1)创建出职责链中包含的各个对象（性敏感词过滤器、脏话词过滤器、政治敏感词过滤器）
    ParWordFilter* pwflinkobj1 = new SexyWordFilter();
    ParWordFilter* pwflinkobj2 = new DirtyWordFilter();
    ParWordFilter* pwflinkobj3 = new PoliticsWordFilter();
    //(2)将这些对象串在一起构成职责链（链表），现在职责链中pwflinkobj1排在最前面，pwflinkobj3排在最后面
    pwflinkobj1->setNextChain(pwflinkobj2);
    pwflinkobj2->setNextChain(pwflinkobj3);
    pwflinkobj3->setNextChain(nullptr);
    string strWordFilterResult = pwflinkobj1->processRequest("你好，这里是过滤敏感词测试范例"); //从职责链中排在最前面的接收者（pwflinkobj1）开始，processRequest的参数代表的是聊天内容
    cout << "对敏感词过滤后的结果为：" << strWordFilterResult << endl;
    //(3)释放资源
    delete pwflinkobj1;
    delete pwflinkobj2;
    delete pwflinkobj3;
    
    return 0;
}

执行结果：

通过与词库比对，在strWord中查找"性"敏感词并用XXX来替换!
通过与词库比对，在strWord中查找"脏话"敏感词并用YYY来替换!
通过与词库比对，在strWord中查找"政治"敏感词并用ZZZ来替换!
对敏感词过滤后的结果为：你好，这里是过滤敏感词测试范例XXXYYYZZZ

从结果可以看到，聊天内容(请求)先经过性敏感词过滤器处理，然后再把处理后的聊天内容(请求)传递给脏话敏感词过滤器，脏话敏感词过滤器处理完后再传递给政治敏感词过滤器,这些过滤器形成了一个链条。链条上的每个过滤器各自承担自己的处理职责,经过多次被处理并被放行传递到下一个过滤器的过程，最终处理结果被返回到strWordFilterResult中。

5. 职责链模式的优点

  • 减少请求的发送者和接收者之间的耦合：发送者和接收者不需要知道彼此的具体细节。
  • 增强了系统的灵活性：可以动态地添加或修改处理链，而不影响其他部分。
  • 增强了给定请求的处理机会：请求可以被多个对象处理，不必绑定到特定的处理者。

6. 职责链模式的缺点

  • 请求可能未被处理：如果链配置不当，请求可能会到达链的末端而未被处理。
  • 性能问题：在某些情况下，由于需要在链上进行多次处理判断，可能会引入性能瓶颈。
  • 调试困难：由于处理过程的动态性，可能难以跟踪请求在链中的传递路径。

7. 职责链模式的适用场景

  1. 多个对象可以处理同一请求：当多个对象都可能对请求进行处理，但具体由哪个对象处理在运行时才确定时，职责链模式提供了一种灵活的处理方式。
  2. 不明确具体接收者：在请求的发送者不需要知道请求的具体接收者是谁的情况下，使用职责链模式可以将发送者和接收者解耦。
  3. 可动态指定处理的顺序：当需要在运行时动态改变请求处理者的顺序或者动态添加新的处理者时，职责链模式能够提供这种灵活性。

总结

职责链模式通过建立一条对象链来处理请求，实现了请求发送者和接收者之间的解耦。它在处理具有不同处理级别的请求时特别有用，如日志记录、异常处理等场景。然而，使用时需要注意避免请求在链中过度传递，以及确保所有请求都能得到适当处理。

完整代码

#include <iostream>
using namespace std;

//加薪请求类
class RaiseRequest
{
public:
    //构造函数
    RaiseRequest(const string& sname, int salfigure) :m_sname(sname), m_isalfigure(salfigure) {}

    //获取请求加薪的人员名字
    const string& getName() const
    {
        return m_sname;
    }
    //获取请求加薪的数字
    int getSalFigure() const
    {
        return m_isalfigure;
    }

private:
    string m_sname;      //请求加薪的人员名字
    int    m_isalfigure; //请求加薪的数字
};

//-------------------
//薪水审批者父类
class ParSalApprover
{
public:
    ParSalApprover() :m_nextChain(nullptr) {}
    virtual ~ParSalApprover() {} //做父类时析构函数应该为虚函数

    //设置指向的职责链中的下个审批者
    void setNextChain(ParSalApprover* next)
    {
        m_nextChain = next;
    }

    //处理加薪请求
    virtual void processRequest(const RaiseRequest& req) = 0;

protected:
    //找链中的下个对象并把请求投递给下个链中的对象
    void sendRequestToNextHandler(const RaiseRequest& req)
    {
        //找链中的下个对象
        if (m_nextChain != nullptr)
        {
            //把请求投递给链中的下个对象
            m_nextChain->processRequest(req);
        }
        else
        {
            //没找到链中的下个对象，程序流程执行这里似乎不应该
            cout << req.getName() << "的加薪要求为：" << req.getSalFigure() << "元，但无人能够审批！" << endl;
        }
    }

private:
    ParSalApprover* m_nextChain; //指向下一个审批者（对象）的多态指针（指向自身类型），每个都指向下一个，就会构成一个职责链（链表）
};

//部门经理子类
class depManager_SA :public ParSalApprover
{
public:
    //处理加薪请求
    virtual void processRequest(const RaiseRequest& req)
    {
        int salfigure = req.getSalFigure();
        if (salfigure <= 1000)
        {
            //如果自己能处理，则自己处理
            cout << req.getName() << "的加薪要求为：" << salfigure << "元，部门经理审批通过！" << endl;
        }
        else
        {
            //自己不能处理，尝试找链中的下个对象来处理
            sendRequestToNextHandler(req);
        }
    }
};

//技术总监子类
class CTO_SA :public ParSalApprover
{
    //处理加薪请求
    virtual void processRequest(const RaiseRequest& req)
    {
        int salfigure = req.getSalFigure();
        if (salfigure > 1000 && salfigure <= 5000)
        {
            //如果自己能处理，则自己处理
            cout << req.getName() << "的加薪要求为：" << salfigure << "元，技术总监审批通过！" << endl;
        }
        else
        {
            sendRequestToNextHandler(req);//自己不能处理，尝试找链中的下个对象来处理
        }
    }
};

//总经理子类
class genManager_SA :public ParSalApprover
{
public:
    //处理加薪请求
    virtual void processRequest(const RaiseRequest& req)
    {
        int salfigure = req.getSalFigure();
        if (salfigure > 5000)
        {
            //如果自己能处理，则自己处理
            cout << req.getName() << "的加薪要求为：" << salfigure << "元，总经理审批通过！" << endl;
        }
        else
        {
            sendRequestToNextHandler(req);//自己不能处理，尝试找链中的下个对象来处理
        }
    }
};

//敏感词过滤器父类
class ParWordFilter
{
public:
    ParWordFilter() :m_nextChain(nullptr) {}
    virtual ~ParWordFilter() {} //做父类时析构函数应该为虚函数

    //设置指向的职责链中的下个过滤器
    void setNextChain(ParWordFilter* next)
    {
        m_nextChain = next;
    }

    //处理敏感词过滤请求
    virtual string processRequest(string strWord) = 0;

protected:
    //找链中的下个对象并把请求投递给下个链中的对象
    string sendRequestToNextHandler(string strWord)
    {
        //找链中的下个对象
        if (m_nextChain != nullptr)
        {
            //把请求投递给链中的下个对象
            return m_nextChain->processRequest(strWord);
        }
        return strWord;
    }
private:
    ParWordFilter* m_nextChain;
};

//性敏感词过滤器子类
class SexyWordFilter :public ParWordFilter
{
public:
    virtual string processRequest(string strWord)
    {
        cout << "通过与词库比对，在strWord中查找\"性\"敏感词并用XXX来替换!" << endl;
        strWord += "XXX"; //测试代码，具体的实现逻辑略......
        return sendRequestToNextHandler(strWord);
    }
};

//脏话词过滤器子类
class DirtyWordFilter :public ParWordFilter
{
public:
    virtual string processRequest(string strWord)
    {
        cout << "通过与词库比对，在strWord中查找\"脏话\"敏感词并用YYY来替换!" << endl;
        strWord += "YYY";
        return sendRequestToNextHandler(strWord);
    }
};

//政治敏感词过滤器子类
class PoliticsWordFilter :public ParWordFilter
{
public:
    virtual string processRequest(string strWord)
    {
        cout << "通过与词库比对，在strWord中查找\"政治\"敏感词并用ZZZ来替换!" << endl;
        strWord += "ZZZ";
        return sendRequestToNextHandler(strWord);
    }
};

int main()
{

    //(1)创建出职责链中包含的各个对象（部门经理、技术总监、总经理）
    ParSalApprover* pzzlinkobj1 = new depManager_SA();
    ParSalApprover* pzzlinkobj2 = new CTO_SA();
    ParSalApprover* pzzlinkobj3 = new genManager_SA();
    //(2)将这些对象串在一起构成职责链（链表），现在职责链中pzzlinkobj1排在最前面，pzzlinkobj3排在最后面
    pzzlinkobj1->setNextChain(pzzlinkobj2);
    pzzlinkobj2->setNextChain(pzzlinkobj3);
    pzzlinkobj3->setNextChain(nullptr); //可以不写此行，因为ParSalApprover构造函数中设置了m_nextChain为nullptr

    //(3)创建几位员工关于加薪的请求（对象）
    RaiseRequest emp1Req("张三", 15000);//张三要求加薪1.5万
    RaiseRequest emp2Req("李四", 3500);//李四要求加薪3千5
    RaiseRequest emp3Req("王二", 800);//王二要求加薪8百
    //看看每位员工的加薪请求由职责链中的哪个对象（部门经理、技术总监、总经理）来处理，从职责链中排在最前面的接收者（pzzlinkobj1）开始
    pzzlinkobj1->processRequest(emp1Req);
    pzzlinkobj1->processRequest(emp2Req);
    pzzlinkobj1->processRequest(emp3Req);

    //(4)释放资源
    delete pzzlinkobj1;
    delete pzzlinkobj2;
    delete pzzlinkobj3;


    //(1)创建出职责链中包含的各个对象（性敏感词过滤器、脏话词过滤器、政治敏感词过滤器）
    ParWordFilter* pwflinkobj1 = new SexyWordFilter();
    ParWordFilter* pwflinkobj2 = new DirtyWordFilter();
    ParWordFilter* pwflinkobj3 = new PoliticsWordFilter();

    //(2)将这些对象串在一起构成职责链（链表），现在职责链中pwflinkobj1排在最前面，pwflinkobj3排在最后面
    pwflinkobj1->setNextChain(pwflinkobj2);
    pwflinkobj2->setNextChain(pwflinkobj3);
    pwflinkobj3->setNextChain(nullptr);
    string strWordFilterResult = pwflinkobj1->processRequest("你好，这里是过滤敏感词测试范例"); //从职责链中排在最前面的接收者（pwflinkobj1）开始，processRequest的参数代表的是聊天内容
    cout << "对敏感词过滤后的结果为：" << strWordFilterResult << endl;

    //(3)释放资源
    delete pwflinkobj1;
    delete pwflinkobj2;
    delete pwflinkobj3;


    return 0;
}
不是仙人的闲人
关注
  • 25
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++设计模式——职责链模式（responsibility chain pattern）
净无邪博客
10-24 595
一、原理讲解 1.1意图 使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。 1.2应用场景 有多个对象可以处理一个请求，哪个对象处理该请求运行时自动确定； 你想在不明确指定接收者的情况下，向多个对象中的一个提交一个请求； 可处理一个请求的对象集合应被动态指定； 1.3结构图（UML图） 1.4代码实现步骤 a1 定义接口迭代器类IHandler，定义一个接口函数request()； a2 定义一个具体处理类Ha
C++设计模式之职责链模式
ACERROR
10-29 241
职责链模式 职责链模式是使多个对象都有机会处理请求，从而避免请求的发送者和接受者之前的耦合关系。在职责链模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这条链上传递，直到链上的某一个对象决定处理此请求。 在公司中不同的岗位拥有不同的职责与权限。以上述的请假流程为例，当X请一天假的时候，只要组长审批就可以了，不需要流转到主管和总监。如果职责链上的某个环节无法处理当前的请求，若含有下个环节，则会把请求转交给下个环节来处理。 职责链上的处理负责处理请求，客户只需要将请求发送到职责链上即可，
C++设计模式——职责链模式( Chain of Responsibility Pattern)
leonardohaig的博客
12-13 1144
C++设计模式——职责链模式( Chain of Responsibility Pattern) 目录 文章目录C++设计模式——职责链模式( Chain of Responsibility Pattern)目录定义代码示例总结参考资料 定义 Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request. Chain the recei
C++设计模式——职责链模式
嵌入式与人工智能
08-16 241
什么是职责链模式？ 在GOF的《设计模式:可复用面向对象软件的基础》一书中对职责链模式是这样说的：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，直到有一个对象处理它为止；如下图： 对于每个角色，他们都有他们的职责；当我提交了休假申请时，项目经理需要判断，看看自己能否处理，如果休假超过了2个小时，那么项目经理就不能处理了；项目经理将这个请求提交到项目主管，项目主管判断部门经理在不在，如果部门经理在，项目主管就不能处理了；最后，我的休假申请就到了部门经理那
C++设计模式——职责链模式(chain of Responsibility)
qq_33766994的博客
03-31 174
职责链模式 在软件的构建中，一个请求可能被多个对象处理，但是每个请求在运行时只能有一个接受者，若显示指定，将带来发送者与接受者之间的紧耦合。 职责链模式就是使多个对象都有机会处理请求，避免请求的发送者和接受者之间的耦合关系，将这些对象连成一条链，并沿着这条链传递请求，直到一个对象处理它为止。 #include<iostream> #include<string> using namespace std; enum class RequestType { REQ_HANDLE1,
【Chain of Resposibility】C++设计模式——职责链
不负AC不负卿的博客
08-09 596
C++职责链，Chain of Reposibility设计模式，本文以通俗易懂的例子引入帮助读者了解职责链，同时归纳了该设计模式的要点，最后展现了伪代码实现的职责链模式
C++ 设计模式——装饰模式
qq_68194402的博客
08-21 1129
装饰模式（Decorator Pattern）是一种结构型设计模式，允许在不改变对象结构的情况下，动态地为对象添加额外的功能。下面是一个基于控件的例子，展示了如何使用装饰模式来增强控件的功能。
C++设计模式——11责任链模式
qq_52553095的博客
09-25 83
#include<iostream> using namespace std; class IHandler { public: IHandler() { mNextHandler = nullptr; } virtual void Exec() { if (nullptr == mNextHandler) {
C++设计模式14——职责链模式
chenyijun的专栏
08-22 1387
什么是职责链模式？ 在GOF的《设计模式:可复用面向对象软件的基础》一书中对职责链模式是这样说的：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，直到有一个对象处理它为止；
设计模式——职责链源码（C++）
12-24
在C++中实现职责链模式，我们需要创建一个抽象处理类，该类定义了处理请求的接口。接着，我们创建一系列具体处理类，它们继承自抽象处理类，并实现处理请求的方法。每个具体处理类都有一个指向下一个处理者的指针，...
设计模式-责任链模式的用法和使用场景分析
张念磊的博客
09-01 790
什么是链？ 1、链是一系列节点的集合。 2.、链的各节点可灵活拆分再重组。 责任链模式（职责链） 使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系， 将这个对象连成一条链，并沿着这条链传递该请求，直到处理完成。 角色 抽象处理者角色(Handler)：定义出一个处理请求的接口。如果需要，接口可以定义 出一个方法以设定和返回对下家的引用。这个角色通常由一个Java抽象类或者Java接口实现。 具体处理者角色(ConcreteHandler)：具体处理者接到请求后，可以选择将请求处理掉，或
C语言如何快速求值
2301_81985098的博客
08-26 1120
4、可得： m = (i + j) / 2， n = (i - j) / 2，i 和 j 要么都是偶数，要么都是奇数。3、设置： m + n = i，m - n = j，i * j =168，i 和 j 至少一个是偶数。一个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？2、计算等式：m2 - n2 = (m + n)(m - n) = 168。1、则：x + 100 = n2, x + 100 + 168 = m2。6、由于 i * j = 168， j>=2，则。
c++命令模式
最新发布
qq_71286244的博客
08-30 510
c++命令模式详细介绍
【C/C++】C++程序设计基础（输入输出、数据类型、动态内存、函数重载、内联函数、常量、引用）
强者征服今天，懦夫哀叹昨天，懒汉坐等明天。
08-28 1817
在后面的章节中，会讲到类与对象，欢迎各位的关注~
C语言破墙镐对称飞迷宫
qq_69383179的博客
08-22 3092
这里有我用C语言编译的破墙镐对称飞迷宫和与之相关的一些东西
[C++规范] 访问类成员变量的方式：直接访问还是通过成员函数访问？
Loewen丶的小窝
08-26 7589
在面向对象编程（OOP）中，通过成员函数（如`ME_HardwareTypeEnum Type() const;` 和 `int Id() const;`）来访问类的私有或受保护成员（如`m_hardwareType` 和 `m_id`），而不是直接通过公共成员访问，是一种更好的做法。
【C++ 面试 - 内存管理】每日 3 题（三）
Newin2020的博客
08-26 1319
栈就像我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。因为操作系统会在底层对栈提供支持，会分配专门的寄存器存放栈的地址，栈的入栈出栈操作也十分简单，并且有专门的指令执行，所以栈的效率比较高也比较快。栈顶和栈底是之前预设好的，栈是向栈底扩展，大小固定，可以通过 ulimit -a 查看，由 ulimit -s 修改。堆就像是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。
适用于 Visual Studio 的 C++ 万能头
Xi Xu 的博客
08-25 1356
修改版本是根据 GNU General Public License v3.0 or later 分发的。原始文件是根据 GNU General Public License v3.0 or later 分发的。用于在 Visual Studio 上预编译的 C++ 包含。文件的修改版本，与 Visual Studio 兼容。此文件是 GCC 13.1.0 中。此文件的配置方法可在互联网上搜索。修改由本文作者完成。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值