C++责任链模式实现动态处理链操作

#include <iostream>
#include <string>
#include <memory> // For std::shared_ptr

// 1. 抽象处理器接口
class IHandler {
public:
    virtual ~IHandler() = default;

    // 设置下一个处理器
    void setNext(std::shared_ptr<IHandler> handler) {
        this->nextHandler = handler;
    }

    // 处理请求的核心方法，返回true表示已处理，false表示未处理
    virtual bool handle(const std::string& request) = 0;

protected:
    // 尝试将请求传递给下一个处理器
    bool passToNext(const std::string& request) {
        if (nextHandler) {
            return nextHandler->handle(request);
        }
        return false; // 链末端，未处理
    }

private:
    std::shared_ptr<IHandler> nextHandler;
};

// 2. 具体处理器A
class ConcreteHandlerA : public IHandler {
public:
    bool handle(const std::string& request) override {
        if (request == "TypeA") {
            std::cout << "Handler A: 处理请求 " << request << std::endl;
            return true; // 请求已处理
        } else {
            std::cout << "Handler A: 无法处理 " << request << ", 传递给下一个..." << std::endl;
            return passToNext(request); // 传递给下一个处理器
        }
    }
};

// 3. 具体处理器B
class ConcreteHandlerB : public IHandler {
public:
    bool handle(const std::string& request) override {
        if (request == "TypeB" || request == "TypeA") { // 故意让B也能处理A，展示处理顺序
            std::cout << "Handler B: 处理请求 " << request << std::endl;
            return true;
        } else {
            std::cout << "Handler B: 无法处理 " << request << ", 传递给下一个..." << std::endl;
            return passToNext(request);
        }
    }
};

// 4. 具体处理器C
class ConcreteHandlerC : public IHandler {
public:
    bool handle(const std::string& request) override {
        if (request == "TypeC") {
            std::cout << "Handler C: 处理请求 " << request << std::endl;
            return true;
        } else {
            std::cout << "Handler C: 无法处理 " << request << ", 传递给下一个..." << std::endl;
            return passToNext(request);
        }
    }
};

// 5. 客户端代码示例
void clientCode(std::shared_ptr<IHandler> handler, const std::string& request) {
    std::cout << "\n客户端发送请求: " << request << std::endl;
    if (!handler->handle(request)) {
        std::cout << "请求 " << request << " 未被任何处理器处理。" << std::endl;
    }
}

int main() {
    // 创建处理器实例
    auto handlerA = std::make_shared<ConcreteHandlerA>();
    auto handlerB = std::make_shared<ConcreteHandlerB>();
    auto handlerC = std::make_shared<ConcreteHandlerC>();

    // 构建处理链：A -> B -> C
    handlerA->setNext(handlerB);
    handlerB->setNext(handlerC);

    // 动态地改变链的顺序，比如 C -> A -> B
    // 只需要修改setNext的调用即可
    // auto handlerC_new = std::make_shared<ConcreteHandlerC>();
    // auto handlerA_new = std::make_shared<ConcreteHandlerA>();
    // auto handlerB_new = std::make_shared<ConcreteHandlerB>();
    // handlerC_new->setNext(handlerA_new);
    // handlerA_new->setNext(handlerB_new);

    // 发送请求
    clientCode(handlerA, "TypeC"); // 应该由C处理
    clientCode(handlerA, "TypeA"); // 应该由A处理
    clientCode(handlerA, "TypeB"); // 应该由B处理
    clientCode(handlerA, "UnknownType"); // 未被处理

    // 动态调整链条：比如移除B，变成 A -> C
    std::cout << "\n--- 动态调整链条：移除Handler B，变成 A -> C ---" << std::endl;
    handlerA->setNext(handlerC); // A直接指向C，B不再是A的下一个处理器

    clientCode(handlerA, "TypeB"); // 现在应该未被处理，因为B被跳过了
    clientCode(handlerA, "TypeA");
    clientCode(handlerA, "TypeC");

    return 0;
}

IHandler

ConcreteHandlerA

B

C

passToNext

setNext

std::shared_ptr

ConcreteHandlerD

switch-case

if-else if

std::shared_ptr

shared_ptr

std::weak_ptr

setNext

handle

false