老廖爱分享后端 2025-07-17

C++如何实现责任链 C++责任链模式的设计有哪些

AI 概述

1. 经典责任链模式实现2. 使用函数对象的责任链实现3. 模板化责任链实现责任链模式的核心要点责任链模式是一种行为设计模式，它允许你将请求沿着处理者链进行传递，直到有一个处理者能够处理该请求。在 C++ 中实现责任链模式主要有以下几种方式： 1. 经典责任链模式实现通过抽象基类定义处理者接口...

文章目录隐藏

1. 经典责任链模式实现
2. 使用函数对象的责任链实现
3. 模板化责任链实现
责任链模式的核心要点

责任链模式是一种行为设计模式，它允许你将请求沿着处理者链进行传递，直到有一个处理者能够处理该请求。在 C++ 中实现责任链模式主要有以下几种方式：

1. 经典责任链模式实现

通过抽象基类定义处理者接口和请求传递机制，具体处理者继承该基类并实现处理逻辑：

#include <iostream>
#include <memory>

// 请求类
struct Request {
    int level;
    std::string message;
};

// 抽象处理者
class Handler {
protected:
    std::shared_ptr<Handler> nextHandler;
public:
    virtual ~Handler() = default;
    
    // 设置下一个处理者
    void setNext(std::shared_ptr<Handler> handler) {
        nextHandler = handler;
    }
    
    // 处理请求的接口
    virtual void handleRequest(const Request& request) {
        if (nextHandler) {
            nextHandler->handleRequest(request);
        } else {
            std::cout << "Request not handled." << std::endl;
        }
    }
};

// 具体处理者 A
class ConcreteHandlerA : public Handler {
public:
    void handleRequest(const Request& request) override {
        if (request.level <= 10) {
            std::cout << "ConcreteHandlerA handled request: " << request.message << std::endl;
        } else {
            Handler::handleRequest(request);
        }
    }
};

// 具体处理者 B
class ConcreteHandlerB : public Handler {
public:
    void handleRequest(const Request& request) override {
        if (request.level > 10 && request.level <= 20) {
            std::cout << "ConcreteHandlerB handled request: " << request.message << std::endl;
        } else {
            Handler::handleRequest(request);
        }
    }
};

// 具体处理者 C
class ConcreteHandlerC : public Handler {
public:
    void handleRequest(const Request& request) override {
        if (request.level > 20) {
            std::cout << "ConcreteHandlerC handled request: " << request.message << std::endl;
        } else {
            Handler::handleRequest(request);
        }
    }
};

int main() {
    // 创建处理者
    auto handlerA = std::make_shared<ConcreteHandlerA>();
    auto handlerB = std::make_shared<ConcreteHandlerB>();
    auto handlerC = std::make_shared<ConcreteHandlerC>();
    
    // 构建责任链
    handlerA->setNext(handlerB);
    handlerB->setNext(handlerC);
    
    // 发送请求
    Request req1{5, "Level 5 request"};
    Request req2{15, "Level 15 request"};
    Request req3{25, "Level 25 request"};
    Request req4{30, "Level 30 request"};
    
    handlerA->handleRequest(req1);
    handlerA->handleRequest(req2);
    handlerA->handleRequest(req3);
    handlerA->handleRequest(req4);
    
    return 0;
}

2. 使用函数对象的责任链实现

这种方式更加灵活，可以使用 lambda 表达式或函数对象作为处理者：

#include <iostream>
#include <vector>
#include <functional>

// 请求类
struct Request {
    int level;
    std::string message;
};

// 责任链类
class ChainOfResponsibility {
private:
    using HandlerFunc = std::function<bool(const Request&)>;
    std::vector<HandlerFunc> handlers;

public:
    // 添加处理者
    void addHandler(HandlerFunc handler) {
        handlers.push_back(handler);
    }
    
    // 处理请求
    void handleRequest(const Request& request) {
        for (const auto& handler : handlers) {
            if (handler(request)) {
                return; // 请求已处理，退出链
            }
        }
        std::cout << "Request not handled." << std::endl;
    }
};

int main() {
    ChainOfResponsibility chain;
    
    // 添加处理者（使用 lambda 表达式）
    chain.addHandler([](const Request& req) {
        if (req.level <= 10) {
            std::cout << "Handler 1 handled request: " << req.message << std::endl;
            return true;
        }
        return false;
    });
    
    chain.addHandler([](const Request& req) {
        if (req.level > 10 && req.level <= 20) {
            std::cout << "Handler 2 handled request: " << req.message << std::endl;
            return true;
        }
        return false;
    });
    
    chain.addHandler([](const Request& req) {
        if (req.level > 20) {
            std::cout << "Handler 3 handled request: " << req.message << std::endl;
            return true;
        }
        return false;
    });
    
    // 发送请求
    Request req1{5, "Level 5 request"};
    Request req2{15, "Level 15 request"};
    Request req3{25, "Level 25 request"};
    
    chain.handleRequest(req1);
    chain.handleRequest(req2);
    chain.handleRequest(req3);
    
    return 0;
}

3. 模板化责任链实现

使用模板可以实现类型安全且灵活的责任链：

#include <iostream>
#include <memory>

// 请求类
struct Request {
    int level;
    std::string message;
};

// 抽象处理者基类
template<typename T>
class Handler {
protected:
    std::shared_ptr<Handler<T>> nextHandler;
public:
    virtual ~Handler() = default;
    
    // 设置下一个处理者
    std::shared_ptr<Handler<T>> setNext(std::shared_ptr<Handler<T>> handler) {
        nextHandler = handler;
        return handler;
    }
    
    // 处理请求的接口
    virtual void handle(const T& request) {
        if (nextHandler) {
            nextHandler->handle(request);
        } else {
            std::cout << "Request not handled." << std::endl;
        }
    }
};

// 具体处理者 A
class ConcreteHandlerA : public Handler<Request> {
public:
    void handle(const Request& request) override {
        if (request.level <= 10) {
            std::cout << "ConcreteHandlerA handled request: " << request.message << std::endl;
        } else {
            Handler::handle(request);
        }
    }
};

// 具体处理者 B
class ConcreteHandlerB : public Handler<Request> {
public:
    void handle(const Request& request) override {
        if (request.level > 10 && request.level <= 20) {
            std::cout << "ConcreteHandlerB handled request: " << request.message << std::endl;
        } else {
            Handler::handle(request);
        }
    }
};

// 具体处理者 C
class ConcreteHandlerC : public Handler<Request> {
public:
    void handle(const Request& request) override {
        if (request.level > 20) {
            std::cout << "ConcreteHandlerC handled request: " << request.message << std::endl;
        } else {
            Handler::handle(request);
        }
    }
};

int main() {
    // 创建处理者
    auto handlerA = std::make_shared<ConcreteHandlerA>();
    auto handlerB = std::make_shared<ConcreteHandlerB>();
    auto handlerC = std::make_shared<ConcreteHandlerC>();
    
    // 构建责任链（使用流式接口）
    handlerA->setNext(handlerB)->setNext(handlerC);
    
    // 发送请求
    Request req1{5, "Level 5 request"};
    Request req2{15, "Level 15 request"};
    Request req3{25, "Level 25 request"};
    
    handlerA->handle(req1);
    handlerA->handle(req2);
    handlerA->handle(req3);
    
    return 0;
}

责任链模式的核心要点

解耦请求发送者和接收者：请求者不需要知道哪个处理者会处理请求，只需将请求发送到链上。
动态组合处理者：可以在运行时动态调整处理者的顺序和组成。
单一职责原则：每个处理者只负责自己的处理逻辑，符合 SRP。
开闭原则：可以在不修改现有代码的情况下添加新的处理者。

根据你的具体需求，可以选择不同的实现方式。经典实现方式适合需要严格控制处理者接口的场景，函数对象方式更加灵活，而模板实现则提供了类型安全的优势。

以上关于C++如何实现责任链 C++责任链模式的设计有哪些的文章就介绍到这了，更多相关内容请搜索码云笔记以前的文章或继续浏览下面的相关文章，希望大家以后多多支持码云笔记。

「点点赞赏，手留余香」

赞 1 赏

给作者打赏，鼓励TA抓紧创作！

微信

支付宝

还没有人赞赏，快来当第一个赞赏的人吧！

声明：本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如若内容造成侵权/违法违规/事实不符，请将相关资料发送至 admin@mybj123.com 进行投诉反馈，一经查实，立即处理！
重要：如软件存在付费、会员、充值等，均属软件开发者或所属公司行为，与本站无关，网友需自行判断
码云笔记 » C++如何实现责任链 C++责任链模式的设计有哪些