在c++++中实现责任链模式的关键在于通过抽象基类定义处理接口，使用指针链接处理对象形成链条，并支持动态调整。1. 抽象基类handler定义处理接口和设置下一个处理者的指针；2. 具体处理者如concretehandlera/b/c继承并实现handlerequest方法，根据请求类型决定是否处理或传递；3. 使用std::unique_ptr管理内存，确保链式结构的自动销毁，避免内存泄漏；4. 通过setnext方法动态增删处理者，实现链的运行时重构；5. 责任链解耦请求发送者与接收者，适用于事件处理、审批流程等场景；6. 避免循环引用的关键是保持单向链结构，必要时使用std::weak_ptr打破共享依赖。该模式提供灵活扩展性，但需注意请求可能未被处理及调试复杂性等问题。
在C++中实现责任链模式，核心在于构建一个处理请求的对象序列，每个对象都有机会处理请求，如果不能处理就将其传递给链中的下一个对象。这种模式的精髓在于解耦请求的发送者和接收者，同时允许链条在运行时动态地增加、删除或重新组织处理者，从而提供极大的灵活性。
C++中责任链模式的实现，说实话，我觉得并不复杂，关键在于理解其核心思想：通过一个抽象基类定义处理者接口，然后具体处理者继承并实现它。请求的传递通常通过一个指向下一个处理者的指针来完成。
#include <iostream>
#include <string>
#include <vector>
#include <memory> // 为了更好的内存管理
// 抽象处理者基类
class Handler {
protected:
std::unique_ptr<Handler> nextHandler; // 指向链中的下一个处理者
public:
virtual ~Handler() = default;
// 设置下一个处理者
void setNext(std::unique_ptr<Handler> handler) {
nextHandler = std::move(handler);
}
// 处理请求的接口
virtual void handleRequest(const std::string& request) = 0;
};
// 具体处理者A
class ConcreteHandlerA : public Handler {
public:
void handleRequest(const std::string& request) override {
if (request == "TypeA") {
std::cout << "ConcreteHandlerA: 处理了请求 " << request << std::endl;
} else if (nextHandler) {
std::cout << "ConcreteHandlerA: 无法处理 " << request << ", 传递给下一个处理者..." << std::endl;
nextHandler->handleRequest(request); // 传递给下一个
} else {
std::cout << "ConcreteHandlerA: 无法处理 " << request << ", 且链中没有下一个处理者。" << std::endl;
}
}
};
// 具体处理者B
class ConcreteHandlerB : public Handler {
public:
void handleRequest(const std::string& request) override {
if (request == "TypeB") {
std::cout << "ConcreteHandlerB: 处理了请求 " << request << std::endl;
} else if (nextHandler) {
std::cout << "ConcreteHandlerB: 无法处理 " << request << ", 传递给下一个处理者..." << std::endl;
nextHandler->handleRequest(request); // 传递给下一个
} else {
std::cout << "ConcreteHandlerB: 无法处理 " << request << ", 且链中没有下一个处理者。" << std::endl;
}
}
};
// 具体处理者C (作为链的末端或默认处理者)
class ConcreteHandlerC : public Handler {
public:
void handleRequest(const std::string& request) override {
if (request == "TypeC" || !nextHandler) { // 如果是TypeC或者已经是链的末尾
std::cout << "ConcreteHandlerC: 处理了请求 " << request << " (或作为默认处理)" << std::endl;
} else {
std::cout << "ConcreteHandlerC: 无法处理 " << request << ", 传递给下一个处理者..." << std::endl;
nextHandler->handleRequest(request); // 传递给下一个
}
}
};
// 客户端代码示例
int main() {
// 构建责任链
auto handlerA = std::make_unique<ConcreteHandlerA>();
auto handlerB = std::make_unique<ConcreteHandlerB>();
auto handlerC = std::make_unique<ConcreteHandlerC>();
// 链式连接：A -> B -> C
handlerA->setNext(std::move(handlerB)); // handlerB现在由handlerA拥有
handlerA->nextHandler->setNext(std::move(handlerC)); // handlerC现在由handlerB拥有
std::cout << "--- 发送请求：TypeA ---" << std::endl;
handlerA->handleRequest("TypeA"); // A处理
std::cout << "\n--- 发送请求：TypeB ---" << std::endl;
handlerA->handleRequest("TypeB"); // A传递给B，B处理
std::cout << "\n--- 发送请求：TypeC ---" << std::endl;
handlerA->handleRequest("TypeC"); // A传递给B，B传递给C，C处理
std::cout << "\n--- 发送请求：UnknownType ---" << std::endl;
handlerA->handleRequest("UnknownType"); // A传递给B，B传递给C，C作为默认处理
// 动态调整链条的例子：移除B，变成 A -> C
// 这块儿就看你的具体需求了，如果需要频繁动态调整，可能需要一个链管理器来封装这些操作
// 这里为了演示，我们假设可以直接访问到链中的元素
// 实际操作中，直接修改unique_ptr指向的nextHandler需要非常小心，
// 因为unique_ptr是独占所有权，转移后原指针就失效了。
// 如果要删除中间节点，通常需要遍历链，找到待删除节点的前一个节点，然后更新其nextHandler。
// 比如要移除B，让A直接指向C，需要先从B那里“取出”C，再把C设置给A。
// 这涉及到unique_ptr的所有权转移和管理，会比shared_ptr复杂一些，
// 但也正是unique_ptr能强制你思考所有权。
// 假设我们有一个方法能安全地移除：
// 简单起见，我们重新构建一个链来模拟动态调整
std::cout << "\n--- 动态调整链条：A -> C ---" << std::endl;
auto newHandlerA = std::make_unique<ConcreteHandlerA>();
auto newHandlerC = std::make_unique<ConcreteHandlerC>();
newHandlerA->setNext(std::move(newHandlerC));
newHandlerA->handleRequest("TypeB"); // A无法处理，传递给C，C作为默认处理
newHandlerA->handleRequest("UnknownType"); // A无法处理，传递给C，C作为默认处理
return 0;
}这个实现中，Handler 是所有处理者的抽象基类，它定义了 setNext 方法来设置链中的下一个处理者，以及 handleRequest 纯虚函数作为处理请求的接口。std::unique_ptr 的使用是我个人推荐的做法，它能很好地管理内存，避免手动释放，并且清晰地表达了所有权关系——每个处理者独占地拥有其链中的下一个处理者。当一个处理者被销毁时，它会自动销毁其拥有的下一个处理者，从而实现整个链的级联销毁，避免内存泄漏。
立即学习“C++免费学习笔记（深入）”；
在C++中，责任链模式对处理者的动态增删支持得相当好，这其实是它设计上的一个亮点。你不需要修改已有的处理者类，只需操作它们之间的“连接”——也就是那个指向下一个处理者的指针。
具体来说，动态增加处理者，无非就是找到链的末端（或者你想要插入的位置），然后把新处理者设置成当前处理者的下一个。比如，如果你想在 HandlerX 后面加一个 NewHandler，你只需要调用 HandlerX->setNext(std::make_unique
动态删除处理者则稍微复杂一点点，因为 unique_ptr 的独占性。如果你想删除链中的某个中间处理者，例如 HandlerB 在 HandlerA -> HandlerB -> HandlerC 这个链中，你需要让 HandlerA 的 nextHandler 直接指向 HandlerC。这意味着 HandlerA 需要获取 HandlerB 所拥有的 HandlerC 的所有权。在 unique_ptr 的语境下，这通常需要 HandlerB 提供一个方法来“释放”它的 nextHandler，或者通过一个外部的链管理器来协调这些所有权转移。一个更直接但也更粗暴的方式是，找到 HandlerB 的前一个节点 HandlerA，然后直接把 HandlerA 的 nextHandler 设置为 nullptr，这样 HandlerB 就会被销毁（如果 HandlerA 是唯一拥有它的），链条就断了。然后，如果你想把 HandlerC 接上，你需要重新 setNext。
实际上，为了更优雅地管理动态链，尤其是涉及到中间节点的增删，你可能会考虑引入一个 ChainManager 类。这个管理器负责创建、存储和连接所有的处理者，并提供方法来动态地添加、移除或重新排序处理者。这样，Handler 类的职责就保持纯粹，只负责处理请求和传递，而链的管理逻辑则集中在 ChainManager 中。这样一来，内存管理也会更清晰，ChainManager 可以用 std::vector<:unique_ptr>> 来存储所有的处理者实例，然后通过原始指针或 std::weak_ptr 来构建链条关系，避免复杂的 unique_ptr 转移操作。
责任链模式，我个人觉得它就像一个流水线，每个工位都有自己的职责，处理不了就往下传。这种设计理念带来了不少好处，当然也有它不那么完美的地方。
优点：
缺点：
适用场景：
处理责任链模式中的内存管理和潜在的循环引用问题，在C++里确实是个值得深思的环节。毕竟，C++的强大也在于它把内存管理权交给了开发者，所以你需要明确所有权关系。
内存管理：
我个人在写这种链式结构时，最推荐的还是使用 std::unique_ptr。它能清晰地表达独占所有权：每个 Handler 对象拥有其 nextHandler。当链的头部（例如 main 函数中创建的第一个 handlerA）被销毁时，它会自动销毁其 nextHandler，然后这个 nextHandler 又会销毁它所拥有的 nextHandler，以此类推，整个链条会像多米诺骨牌一样被安全地销毁，完全避免了内存泄漏。
// 示例：使用unique_ptr的链式销毁 // main函数中： auto headHandler = std::make_unique<ConcreteHandlerA>(); headHandler->setNext(std::make_unique<ConcreteHandlerB>()); headHandler->nextHandler->setNext(std::make_unique<ConcreteHandlerC>()); // 当headHandler超出作用域时，整个链条会被自动、安全地销毁。
如果你选择使用 std::shared_ptr，那么内存管理会变得稍微复杂一些，因为它引入了共享所有权的概念。每个 Handler 可以持有其 nextHandler 的 shared_ptr。这在某些场景下有用，比如当链中的某个处理者可能被多个链或多个地方引用时。但需要注意的是，shared_ptr 最大的坑就是循环引用。
循环引用：
在经典的责任链模式中，如果每个处理者只持有指向“下一个”处理者的指针（nextHandler），那么通常不会出现循环引用。链条是单向的：A -> B -> C。没有哪个处理者会指向链中的上一个处理者，也不会有某个处理者指向链的头部形成一个环。
循环引用主要发生在 std::shared_ptr 的场景下，当两个或多个对象相互持有对方的 shared_ptr，导致它们的引用计数永远不会降到零，从而无法被释放。
例如，如果你的 Handler 除了 nextHandler 之外，还意外地持有一个 shared_ptr 指向它的“上一个”处理者，或者指向管理整个链的 ChainManager，而 ChainManager 又持有 shared_ptr 指向链中的处理者，那么循环引用就可能发生。
解决方案：
// 假设你有一个场景需要反向引用，但这不是典型的责任链模式
class Parent;
class Child {
public:
std::shared_ptr<Parent> parent; // 错误：如果Parent也持有Child的shared_ptr，会循环引用
std::weak_ptr<Parent> weakParent; // 正确：使用weak_ptr打破循环
};
class Parent {
public:
std::shared_ptr<Child> child;
};在责任链模式中，只要你保持 nextHandler 是单向的，并且使用 unique_ptr 来管理，基本上就不会遇到这些复杂的内存和循环引用问题。如果需要更复杂的链管理（比如动态插入、删除中间节点），可以考虑引入一个独立的 ChainManager 类来持有所有处理者的 unique_ptr，然后处理者之间通过原始指针或 weak_ptr 建立关系，这样所有权集中管理，链的结构调整也更灵活。
以上就是C++责任链模式如何实现 请求传递与处理者动态链的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
广告![ThinkPHP5快速开发企业站点[全程实录]](https://img.php.cn/upload/course/000/000/068/6253d918a3ce7278.png)
收藏
收藏
Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
476
