设计模式13之c++职责链模式(含示例代码)

C++ 职责链模式（Chain of Responsibility Pattern）是一种行为型设计模式，它允许你将请求沿着处理者链进行传递，直到其中一个处理者能够处理它为止。

适用场景

在以下情况下可以使用职责链模式：

有多个对象可以处理一个请求，但你不确定哪个对象应该处理这个请求。你希望将请求从对象中解耦，并使其自动沿着对象链进行传递，以便在运行时动态添加或删除处理程序。

示例代码

#include 
#include 
class Handler {
public:
    virtual ~Handler() {}
    virtual void setNext(std::shared_ptr<Handler> handler) = 0;
    virtual void handle(int request) = 0;
};
class ConcreteHandler1 : public Handler {
public:
    void setNext(std::shared_ptr<Handler> handler) override {
        nextHandler_ = handler;
    }
    void handle(int request) override {
        if (request >= 0 && request < 10) {
            std::cout << "ConcreteHandler1 handles request " << request << std::endl;
        } else if (nextHandler_) {
            nextHandler_->handle(request);
        } else {
            std::cout << "No handler can handle request " << request << std::endl;
        }
    }
private:
    std::shared_ptr<Handler> nextHandler_;
};
class ConcreteHandler2 : public Handler {
public:
    void setNext(std::shared_ptr<Handler> handler) override {
        nextHandler_ = handler;
    }
    void handle(int request) override {
        if (request >= 10 && request < 20) {
            std::cout << "ConcreteHandler2 handles request " << request << std::endl;
        } else if (nextHandler_) {
            nextHandler_->handle(request);
        } else {
            std::cout << "No handler can handle request " << request << std::endl;
        }
    }
private:
    std::shared_ptr<Handler> nextHandler_;
};
class ConcreteHandler3 : public Handler {
public:
    void setNext(std::shared_ptr<Handler> handler) override {
        nextHandler_ = handler;
    }
    void handle(int request) override {
        if (request >= 20 && request < 30) {
            std::cout << "ConcreteHandler3 handles request " << request << std::endl;
        } else if (nextHandler_) {
            nextHandler_->handle(request);
        } else {
            std::cout << "No handler can handle request " << request << std::endl;
        }
    }
private:
    std::shared_ptr<Handler> nextHandler_;
};
int main() {
    std::shared_ptr<Handler> handler1 = std::make_shared<ConcreteHandler1>();
    std::shared_ptr<Handler> handler2 = std::make_shared<ConcreteHandler2>();
    std::shared_ptr<Handler> handler3 = std::make_shared<ConcreteHandler3>();
    handler1->setNext(handler2);
    handler2->setNext(handler3);
    handler1->handle(5);
    handler1->handle(15);
    handler1->handle(25);
    handler1->handle(35);
    return 0;
}

在上面的示例代码中，我们创建了一个处理器链，其中每个处理器都有不同的处理能力。当客户端发送一个请求时，处理器链中的第一个处理器将尝试处理该请求。如果它无法处理该请求，则该请求将被传递给下一个处理器。如果所有处理器都无法处理该请求，则客户端将收到一个“无法处理该请求”的错误消息。
在我们的示例中，ConcreteHandler1、ConcreteHandler2 和 ConcreteHandler3 都实现了 Handler 接口，并且可以通过 setNext() 方法将它们链接在一起。当客户端发送一个请求时，它将首先被 ConcreteHandler1 处理。如果 ConcreteHandler1 无法处理该请求，则该请求将被传递给 ConcreteHandler2，然后再传递给 ConcreteHandler3。如果 ConcreteHandler3 无法处理该请求，则客户端将收到一个错误消息。

职责链模式

职责链模式为您提供了一种将请求从对象中解耦的方法，并将其自动沿着对象链传递的能力。它可以帮助你减少对象之间的耦合度，并使你的代码更加灵活和可扩展。