C++责任链模式怎么实现 动态链式处理请求的设计方法

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

// 请求的基类或结构
struct Request {
    std::string type;
    std::string content;
    bool handled = false;
};

// 抽象处理器基类
class Handler {
protected:
    std::unique_ptr<Handler> next_handler_; // 使用智能指针管理下一个处理器的生命周期

public:
    virtual ~Handler() = default;

    // 设置下一个处理器
    Handler* set_next(std::unique_ptr<Handler> handler) {
        next_handler_ = std::move(handler);
        return next_handler_.get(); // 返回原始指针方便链式调用
    }

    // 纯虚函数，处理请求的核心逻辑
    virtual void handle_request(Request& request) = 0;

    // 辅助方法，用于将请求传递给链中的下一个处理器
    void pass_to_next(Request& request) {
        if (next_handler_) {
            next_handler_->handle_request(request);
        } else {
            // 链的末端，请求未被处理
            if (!request.handled) {
                std::cout << "Request '" << request.type << "' could not be handled by any handler in the chain.\n";
            }
        }
    }
};

// 具体处理器A
class ConcreteHandlerA : public Handler {
public:
    void handle_request(Request& request) override {
        if (request.type == "TypeA") {
            std::cout << "Handler A: Handling request of TypeA: " << request.content << std::endl;
            request.handled = true;
        } else {
            std::cout << "Handler A: Cannot handle Type " << request.type << ", passing to next.\n";
            pass_to_next(request); // 传递给下一个处理器
        }
    }
};

// 具体处理器B
class ConcreteHandlerB : public Handler {
public:
    void handle_request(Request& request) override {
        if (request.type == "TypeB") {
            std::cout << "Handler B: Handling request of TypeB: " << request.content << std::endl;
            request.handled = true;
        } else {
            std::cout << "Handler B: Cannot handle Type " << request.type << ", passing to next.\n";
            pass_to_next(request); // 传递给下一个处理器
        }
    }
};

// 具体处理器C
class ConcreteHandlerC : public Handler {
public:
    void handle_request(Request& request) override {
        if (request.type == "TypeC") {
            std::cout << "Handler C: Handling request of TypeC: " << request.content << std::endl;
            request.handled = true;
        } else {
            std::cout << "Handler C: Cannot handle Type " << request.type << ", passing to next.\n";
            pass_to_next(request); // 传递给下一个处理器
        }
    }
};

// 客户端代码示例
/*
int main() {
    // 构建责任链
    std::unique_ptr<Handler> handlerA = std::make_unique<ConcreteHandlerA>();
    std::unique_ptr<Handler> handlerB = std::make_unique<ConcreteHandlerB>();
    std::unique_ptr<Handler> handlerC = std::make_unique<ConcreteHandlerC>();

    // 动态链式构建：A -> B -> C
    handlerA->set_next(std::move(handlerB))->set_next(std::move(handlerC));

    // 发送请求
    Request req1 = {"TypeA", "Process this TypeA request"};
    handlerA->handle_request(req1);
    std::cout << "--------------------\n";

    Request req2 = {"TypeB", "Process this TypeB request"};
    handlerA->handle_request(req2);
    std::cout << "--------------------\n";

    Request req3 = {"TypeC", "Process this TypeC request"};
    handlerA->handle_request(req3);
    std::cout << "--------------------\n";

    Request req4 = {"TypeD", "This is an unhandled request"};
    handlerA->handle_request(req4);
    std::cout << "--------------------\n";

    // 动态调整链：例如，只用B和C，或者调整顺序
    std::cout << "--- Dynamic Chain Adjustment Example ---\n";
    std::unique_ptr<Handler> new_handlerB = std::make_unique<ConcreteHandlerB>();
    std::unique_ptr<Handler> new_handlerC = std::make_unique<ConcreteHandlerC>();
    new_handlerB->set_next(std::move(new_handlerC)); // 新链：B -> C

    Request req5 = {"TypeC", "Process this TypeC request with new chain"};
    new_handlerB->handle_request(req5);
    std::cout << "--------------------\n";

    return 0;
}
*/

if-else if-else

set_next

std::unique_ptr

std::shared_ptr

std::unique_ptr<Handler> next_handler_

set_next

next_handler_

std::shared_ptr

next_handler_

next_handler_A_->handle_request()

next_handler_B_->handle_request()