用C++实现责任链模式

下面是一个用C++实现责任链模式的示例代码：

#include <iostream>
#include <string>

class Handler {
public:
    virtual void setNext(Handler* next) = 0;
    virtual void handleRequest(const std::string& request) = 0;
};

class ConcreteHandler1 : public Handler {
private:
    Handler* nextHandler;
public:
    ConcreteHandler1() : nextHandler(nullptr) {}
    void setNext(Handler* next) override {
        nextHandler = next;
    }
    void handleRequest(const std::string& request) override {
        if (request == "Request1") {
            std::cout << "ConcreteHandler1 handles the request." << std::endl;
        }
        else if (nextHandler != nullptr) {
            nextHandler->handleRequest(request);
        }
        else {
            std::cout << "No handler can handle the request." << std::endl;
        }
    }
};

class ConcreteHandler2 : public Handler {
private:
    Handler* nextHandler;
public:
    ConcreteHandler2() : nextHandler(nullptr) {}
    void setNext(Handler* next) override {
        nextHandler = next;
    }
    void handleRequest(const std::string& request) override {
        if (request == "Request2") {
            std::cout << "ConcreteHandler2 handles the request." << std::endl;
        }
        else if (nextHandler != nullptr) {
            nextHandler->handleRequest(request);
        }
        else {
            std::cout << "No handler can handle the request." << std::endl;
        }
    }
};

class ConcreteHandler3 : public Handler {
private:
    Handler* nextHandler;
public:
    ConcreteHandler3() : nextHandler(nullptr) {}
    void setNext(Handler* next) override {
        nextHandler = next;
    }
    void handleRequest(const std::string& request) override {
        if (request == "Request3") {
            std::cout << "ConcreteHandler3 handles the request." << std::endl;
        }
        else if (nextHandler != nullptr) {
            nextHandler->handleRequest(request);
        }
        else {
            std::cout << "No handler can handle the request." << std::endl;
        }
    }
};

int main() {
    Handler* handler1 = new ConcreteHandler1();
    Handler* handler2 = new ConcreteHandler2();
    Handler* handler3 = new ConcreteHandler3();

    handler1->setNext(handler2);
    handler2->setNext(handler3);

    handler1->handleRequest("Request1");
    handler1->handleRequest("Request2");
    handler1->handleRequest("Request3");
    handler1->handleRequest("Request4");

    delete handler1;
    delete handler2;
    delete handler3;

    return 0;
}

运行上述代码，输出结果为：

ConcreteHandler1 handles the request.
ConcreteHandler2 handles the request.
ConcreteHandler3 handles the request.
No handler can handle the request.

这个示例中，有三个具体的处理器类：ConcreteHandler1、ConcreteHandler2和ConcreteHandler3，它们分别负责处理"Request1"、"Request2"和"Request3"请求。每个处理器都有一个setNext方法来设置下一个处理器，当当前处理器无法处理请求时，会将请求传递给下一个处理器。

在main函数中，我们创建了三个处理器对象，并通过setNext方法将它们连接成一个处理器链。然后，我们通过handleRequest方法向处理器链发送不同的请求，观察每个请求是由哪个处理器来处理。最后，我们释放了创建的处理器对象