编辑“︁C++ 责任链模式”︁

= C++责任链模式 =

责任链模式（Chain of Responsibility Pattern）是一种行为设计模式，允许你将请求沿着处理链传递，直到有一个处理者能够处理该请求。这种模式解耦了请求的发送者和接收者，允许多个对象都有机会处理请求。

== 介绍 ==
责任链模式的核心思想是构建一个处理对象的链，每个处理对象包含对另一个处理对象的引用。当一个请求被发送到链中时，处理对象可以决定是否处理该请求，或者将其传递给链中的下一个处理对象。

在C++中，责任链模式通常通过指针或引用将处理者连接起来，每个处理者实现相同的接口或基类。

== 结构 ==
责任链模式的主要组成部分包括：
* '''Handler（处理者接口）'''：定义一个处理请求的接口，通常包含一个指向下一个处理者的引用。
* '''ConcreteHandler（具体处理者）'''：实现处理请求的具体逻辑，决定是否处理请求或将其传递给下一个处理者。
* '''Client（客户端）'''：创建处理链并向链的头部发送请求。

以下是一个简单的类图表示：

<mermaid>
classDiagram
    class Handler {
        +Handler* nextHandler
        +setNext(Handler* handler)
        +handleRequest(Request request)
    }
    class ConcreteHandlerA {
        +handleRequest(Request request)
    }
    class ConcreteHandlerB {
        +handleRequest(Request request)
    }
    class Client {
        -Handler* chain
    }
    Handler <|-- ConcreteHandlerA
    Handler <|-- ConcreteHandlerB
    Handler o-- Handler
    Client --> Handler
</mermaid>

== 代码示例 ==
以下是一个简单的C++实现，展示责任链模式的基本用法：

<syntaxhighlight lang="cpp">
#include <iostream>
#include <string>

// 请求类
class Request {
public:
    std::string type;
    int value;
    Request(const std::string& t, int v) : type(t), value(v) {}
};

// 处理者接口
class Handler {
protected:
    Handler* nextHandler;
public:
    Handler() : nextHandler(nullptr) {}
    virtual ~Handler() = default;
    
    void setNext(Handler* handler) {
        nextHandler = handler;
    }
    
    virtual void handleRequest(const Request& req) = 0;
};

// 具体处理者A
class ConcreteHandlerA : public Handler {
public:
    void handleRequest(const Request& req) override {
        if (req.type == "TypeA") {
            std::cout << "ConcreteHandlerA 处理了类型为 " << req.type 
                      << " 的请求，值为 " << req.value << std::endl;
        } else if (nextHandler != nullptr) {
            nextHandler->handleRequest(req);
        } else {
            std::cout << "没有处理者能处理此请求" << std::endl;
        }
    }
};

// 具体处理者B
class ConcreteHandlerB : public Handler {
public:
    void handleRequest(const Request& req) override {
        if (req.type == "TypeB") {
            std::cout << "ConcreteHandlerB 处理了类型为 " << req.type 
                      << " 的请求，值为 " << req.value << std::endl;
        } else if (nextHandler != nullptr) {
            nextHandler->handleRequest(req);
        } else {
            std::cout << "没有处理者能处理此请求" << std::endl;
        }
    }
};

int main() {
    // 创建处理链
    Handler* handlerA = new ConcreteHandlerA();
    Handler* handlerB = new ConcreteHandlerB();
    handlerA->setNext(handlerB);
    
    // 创建请求
    Request req1("TypeA", 10);
    Request req2("TypeB", 20);
    Request req3("TypeC", 30);
    
    // 发送请求
    handlerA->handleRequest(req1);
    handlerA->handleRequest(req2);
    handlerA->handleRequest(req3);
    
    delete handlerA;
    delete handlerB;
    return 0;
}
</syntaxhighlight>

'''输出结果：'''
<pre>
ConcreteHandlerA 处理了类型为 TypeA 的请求，值为 10
ConcreteHandlerB 处理了类型为 TypeB 的请求，值为 20
没有处理者能处理此请求
</pre>

== 实际应用场景 ==
责任链模式在以下场景中特别有用：

1. '''多级审批系统'''：例如公司中的请假审批流程，不同级别的领导有不同的审批权限。
2. '''事件处理系统'''：GUI框架中，事件可能被多个处理器依次尝试处理。
3. '''日志系统'''：不同级别的日志消息可能被不同处理器处理（控制台、文件、网络等）。
4. '''异常处理'''：异常可以在调用栈中向上传递，直到被捕获。

=== 多级审批示例 ===
以下是一个简化的多级审批系统示例：

<syntaxhighlight lang="cpp">
#include <iostream>
#include <string>

class ApprovalRequest {
public:
    std::string content;
    double amount;
    ApprovalRequest(const std::string& c, double a) : content(c), amount(a) {}
};

class Approver {
protected:
    Approver* nextApprover;
    std::string name;
    double approvalLimit;
public:
    Approver(const std::string& n, double limit) 
        : name(n), approvalLimit(limit), nextApprover(nullptr) {}
    
    void setNext(Approver* approver) {
        nextApprover = approver;
    }
    
    virtual void processRequest(const ApprovalRequest& req) {
        if (req.amount <= approvalLimit) {
            std::cout << name << " 批准了申请: " << req.content 
                      << " 金额: " << req.amount << std::endl;
        } else if (nextApprover != nullptr) {
            nextApprover->processRequest(req);
        } else {
            std::cout << "申请需要董事会批准: " << req.content 
                      << " 金额: " << req.amount << std::endl;
        }
    }
};

int main() {
    // 创建审批链
    Approver* manager = new Approver("部门经理", 1000);
    Approver* director = new Approver("总监", 5000);
    Approver* vp = new Approver("副总裁", 10000);
    
    manager->setNext(director);
    director->setNext(vp);
    
    // 创建审批请求
    ApprovalRequest req1("购买办公用品", 800);
    ApprovalRequest req2("团队建设活动", 4500);
    ApprovalRequest req3("新服务器采购", 15000);
    
    // 处理请求
    manager->processRequest(req1);
    manager->processRequest(req2);
    manager->processRequest(req3);
    
    delete manager;
    delete director;
    delete vp;
    return 0;
}
</syntaxhighlight>

'''输出结果：'''
<pre>
部门经理 批准了申请: 购买办公用品 金额: 800
总监 批准了申请: 团队建设活动 金额: 4500
申请需要董事会批准: 新服务器采购 金额: 15000
</pre>

== 优缺点 ==
'''优点：'''
* 降低耦合度：请求发送者不需要知道哪个对象会处理请求
* 动态添加或修改处理链
* 可以灵活地分配责任给多个对象

'''缺点：'''
* 请求可能未被处理（如果没有合适的处理者）
* 可能影响性能，特别是在长链中
* 调试可能较复杂

== 与其他模式的关系 ==
* 责任链模式常与'''组合模式'''一起使用，此时处理者的父类可以同时作为组合模式的组件接口。
* 责任链模式与'''命令模式'''可以结合使用，命令对象可以作为请求在链中传递。
* 责任链模式与'''装饰器模式'''结构相似，但目的不同：装饰器模式是动态添加功能，而责任链模式是传递请求直到被处理。

== 总结 ==
责任链模式是一种强大的行为设计模式，特别适合处理需要多个对象按顺序处理请求的场景。通过将处理者组织成链，我们可以实现灵活的请求处理机制，同时保持代码的低耦合性。在C++中，通过指针或引用实现处理者之间的连接，可以高效地构建处理链。

[[Category:编程语言]]
[[Category:C++]]
[[Category:C++ 高级主题]]