C++责任链模式实现请求传递与处理

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

// 1. 定义请求
struct Request {
    std::string type;
    std::string content;
    int priority;

    Request(std::string t, std::string c, int p) : type(std::move(t)), content(std::move(c)), priority(p) {}
};

// 2. 抽象处理器基类
class Handler {
protected:
    std::shared_ptr<Handler> nextHandler; // 使用智能指针管理下一个处理器

public:
    virtual ~Handler() = default; // 虚析构函数确保正确释放资源

    void setNext(std::shared_ptr<Handler> handler) {
        this->nextHandler = handler;
    }

    // 纯虚函数，要求子类实现具体的处理逻辑
    virtual void handleRequest(const Request& request) = 0;
};

// 3. 具体处理器A：低优先级请求处理器
class LowPriorityHandler : public Handler {
public:
    void handleRequest(const Request& request) override {
        if (request.priority <= 3) {
            std::cout << "LowPriorityHandler: 处理请求 [" << request.type << "] - " << request.content << std::endl;
        } else if (nextHandler) {
            std::cout << "LowPriorityHandler: 无法处理优先级 " << request.priority << " 的请求，转发给下一个处理器。" << std::endl;
            nextHandler->handleRequest(request);
        } else {
            std::cout << "LowPriorityHandler: 无法处理请求，且链中没有下一个处理器。" << std::endl;
        }
    }
};

// 4. 具体处理器B：中优先级请求处理器
class MediumPriorityHandler : public Handler {
public:
    void handleRequest(const Request& request) override {
        if (request.priority > 3 && request.priority <= 7) {
            std::cout << "MediumPriorityHandler: 处理请求 [" << request.type << "] - " << request.content << std::endl;
        } else if (nextHandler) {
            std::cout << "MediumPriorityHandler: 无法处理优先级 " << request.priority << " 的请求，转发给下一个处理器。" << std::endl;
            nextHandler->handleRequest(request);
        } else {
            std::cout << "MediumPriorityHandler: 无法处理请求，且链中没有下一个处理器。" << std::endl;
        }
    }
};

// 5. 具体处理器C：高优先级请求处理器
class HighPriorityHandler : public Handler {
public:
    void handleRequest(const Request& request) override {
        if (request.priority > 7) {
            std::cout << "HighPriorityHandler: 处理请求 [" << request.type << "] - " << request.content << std::endl;
        } else if (nextHandler) {
            // 理论上这里不会发生，因为高优先级是最高层，但为了完整性保留
            std::cout << "HighPriorityHandler: 无法处理优先级 " << request.priority << " 的请求，转发给下一个处理器。" << std::endl;
            nextHandler->handleRequest(request);
        } else {
            std::cout << "HighPriorityHandler: 无法处理请求，且链中没有下一个处理器。" << std::endl;
        }
    }
};

// 客户端代码
int main() {
    // 创建处理器实例
    auto lowHandler = std::make_shared<LowPriorityHandler>();
    auto mediumHandler = std::make_shared<MediumPriorityHandler>();
    auto highHandler = std::make_shared<HighPriorityHandler>();

    // 构建责任链：low -> medium -> high
    lowHandler->setNext(mediumHandler);
    mediumHandler->setNext(highHandler);

    // 发送请求
    std::cout << "--- 发送请求 ---" << std::endl;
    lowHandler->handleRequest(Request("Bug Report", "UI 崩溃问题", 2));
    lowHandler->handleRequest(Request("Feature Request", "增加暗黑模式", 6));
    lowHandler->handleRequest(Request("Urgent Fix", "生产环境数据丢失", 9));
    lowHandler->handleRequest(Request("General Query", "如何使用XXX功能", 4));
    lowHandler->handleRequest(Request("Unclassified", "未知问题", 0)); // 故意设置一个所有处理器都可能无法处理的请求，看最终结果

    return 0;
}

main

lowHandler

std::shared_ptr

delete

if-else if

handleRequest

A->B

B->A

std::shared_ptr

nextHandler

std::shared_ptr

std::weak_ptr