怎样用C++实现责任链模式 请求传递与处理链的构建技巧

// 抽象请求基类
class Request {
public:
    enum Type {
        TYPE_A,
        TYPE_B,
        TYPE_C
    };
    Request(Type t) : type_(t) {}
    Type getType() const { return type_; }
    // 可以在这里添加更多请求相关的属性或方法
private:
    Type type_;
};

// 抽象处理器基类
class Handler {
protected:
    Handler* nextHandler; // 指向链中下一个处理器

public:
    Handler() : nextHandler(nullptr) {}
    virtual ~Handler() {}

    void setNext(Handler* handler) {
        nextHandler = handler;
    }

    // 核心处理方法，返回bool表示是否已处理
    virtual bool handleRequest(Request* req) = 0;

    // 默认的传递行为
    bool passToNext(Request* req) {
        if (nextHandler) {
            return nextHandler->handleRequest(req);
        }
        return false; // 链末端，请求未被处理
    }
};

// 具体处理器A
class ConcreteHandlerA : public Handler {
public:
    bool handleRequest(Request* req) override {
        if (req->getType() == Request::TYPE_A) {
            std::cout << "ConcreteHandlerA 处理了请求 Type A" << std::endl;
            // 实际处理逻辑...
            return true;
        } else {
            std::cout << "ConcreteHandlerA 无法处理请求，传递给下一个..." << std::endl;
            return passToNext(req); // 无法处理，传递给下一个
        }
    }
};

// 具体处理器B
class ConcreteHandlerB : public Handler {
public:
    bool handleRequest(Request* req) override {
        if (req->getType() == Request::TYPE_B) {
            std::cout << "ConcreteHandlerB 处理了请求 Type B" << std::endl;
            // 实际处理逻辑...
            return true;
        } else {
            std::cout << "ConcreteHandlerB 无法处理请求，传递给下一个..." << std::endl;
            return passToNext(req);
        }
    }
};

// 具体处理器C
class ConcreteHandlerC : public Handler {
public:
    bool handleRequest(Request* req) override {
        if (req->getType() == Request::TYPE_C) {
            std::cout << "ConcreteHandlerC 处理了请求 Type C" << std::endl;
            // 实际处理逻辑...
            return true;
        } else {
            std::cout << "ConcreteHandlerC 无法处理请求，传递给下一个..." << std::endl;
            return passToNext(req);
        }
    }
};

// 客户端代码示例
/*
int main() {
    // 创建处理器实例
    Handler* handlerA = new ConcreteHandlerA();
    Handler* handlerB = new ConcreteHandlerB();
    Handler* handlerC = new ConcreteHandlerC();

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

    // 创建并发送请求
    Request* req1 = new Request(Request::TYPE_A);
    Request* req2 = new Request(Request::TYPE_B);
    Request* req3 = new Request(Request::TYPE_C);
    Request* req4 = new Request(static_cast<Request::Type>(99)); // 未知类型

    std::cout << "--- 发送请求 Type A ---" << std::endl;
    if (!handlerA->handleRequest(req1)) {
        std::cout << "请求 Type A 未被处理。" << std::endl;
    }

    std::cout << "\n--- 发送请求 Type B ---" << std::endl;
    if (!handlerA->handleRequest(req2)) {
        std::cout << "请求 Type B 未被处理。" << std::endl;
    }

    std::cout << "\n--- 发送请求 Type C ---" << std::endl;
    if (!handlerA->handleRequest(req3)) {
        std::cout << "请求 Type C 未被处理。" << std::endl;
    }

    std::cout << "\n--- 发送未知类型请求 ---" << std::endl;
    if (!handlerA->handleRequest(req4)) {
        std::cout << "请求未知类型 未被处理。" << std::endl;
    }

    // 清理
    delete handlerA;
    delete handlerB;
    delete handlerC;
    delete req1;
    delete req2;
    delete req3;
    delete req4;

    return 0;
}
*/

// 简单的链式构建器概念
class ChainBuilder {
private:
    Handler* head = nullptr;
    Handler* tail = nullptr;

public:
    ChainBuilder& addHandler(Handler* handler) {
        if (!head) {
            head = handler;
            tail = handler;
        } else {
            tail->setNext(handler);
            tail = handler;
        }
        return *this;
    }

    Handler* build() {
        return head;
    }
};

/*
// 使用示例
int main() {
    Handler* chain = ChainBuilder()
                        .addHandler(new ConcreteHandlerA())
                        .addHandler(new ConcreteHandlerB())
                        .addHandler(new ConcreteHandlerC())
                        .build();

    // 发送请求...
    // 记得清理 chain 中所有 handler 的内存
}
*/

// 抽象请求基类
class BaseRequest {
public:
    virtual ~BaseRequest() = default;
    // 允许请求携带一些通用信息
    std::string requestID;
};

// 具体请求类型
class NetworkRequest : public BaseRequest {
public:
    std::string url;
    // ... 其他网络请求特有属性
};

class FileAccessRequest : public BaseRequest {
public:
    std::string filePath;
    // ... 其他文件访问特有属性
};

// 抽象处理器基类
class Handler {
protected:
    Handler* nextHandler;
public:
    Handler() : nextHandler(nullptr) {}
    virtual ~Handler() {}
    void setNext(Handler* handler) { nextHandler = handler; }
    virtual bool handleRequest(BaseRequest* req) = 0; // 统一处理BaseRequest
    bool passToNext(BaseRequest* req) {
        if (nextHandler) {
            return nextHandler->handleRequest(req);
        }
        return false;
    }
};

// 具体处理器，处理特定类型的请求
class NetworkRequestHandler : public Handler {
public:
    bool handleRequest(BaseRequest* req) override {
        // 尝试向下转型
        if (NetworkRequest* netReq = dynamic_cast<NetworkRequest*>(req)) {
            std::cout << "NetworkRequestHandler 处理了网络请求: " << netReq->url << std::endl;
            // 实际处理逻辑...
            return true;
        } else {
            return passToNext(req); // 无法处理，传递给下一个
        }
    }
};

class FileAccessHandler : public Handler {
public:
    bool handleRequest(BaseRequest* req) override {
        if (FileAccessRequest* fileReq = dynamic_cast<FileAccessRequest*>(req)) {
            std::cout << "FileAccessHandler 处理了文件访问请求: " << fileReq->filePath << std::endl;
            // 实际处理逻辑...
            return true;
        } else {
            return passToNext(req);
        }
    }
};