设计模式：责任链模式（C++实现）

责任链模式（Chain of Responsibility Pattern）是一种行为设计模式，它能够将请求从一个处理者传递到下一个处理者，直到找到能够处理请求的对象为止。责任链模式可以实现请求的解耦和动态的处理链。
下面是一个简单的C++责任链模式的示例：

#include 

// 抽象处理者类
class Handler
{
protected:
    Handler *successor;

public:
    Handler() : successor(nullptr) {}
    void setSuccessor(Handler *successor)
    {
        this->successor = successor;
    }
    virtual void handleRequest(int request) = 0;
};

// 具体处理者类A
class ConcreteHandlerA : public Handler
{
public:
    void handleRequest(int request) override
    {
        if (request >= 0 && request < 10)
        {
            std::cout << "Concrete Handler A handles the request." << std::endl;
        }
        else if (successor != nullptr)
        {
            successor->handleRequest(request);
        }
    }
};

// 具体处理者类B
class ConcreteHandlerB : public Handler
{
public:
    void handleRequest(int request) override
    {
        if (request >= 10 && request < 20)
        {
            std::cout << "Concrete Handler B handles the request." << std::endl;
        }
        else if (successor != nullptr)
        {
            successor->handleRequest(request);
        }
    }
};

// 具体处理者类C
class ConcreteHandlerC : public Handler
{
public:
    void handleRequest(int request) override
    {
        if (request >= 20 && request < 30)
        {
            std::cout << "Concrete Handler C handles the request." << std::endl;
        }
        else if (successor != nullptr)
        {
            successor->handleRequest(request);
        }
    }
};

int main()
{
    Handler *handlerA = new ConcreteHandlerA();
    Handler *handlerB = new ConcreteHandlerB();
    Handler *handlerC = new ConcreteHandlerC();
    handlerA->setSuccessor(handlerB);
    handlerB->setSuccessor(handlerC);
    handlerA->handleRequest(15);
    handlerA->handleRequest(20);
    handlerA->handleRequest(5);
    delete handlerA;
    delete handlerB;
    delete handlerC;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

运行结果：

Concrete Handler B handles the request.
Concrete Handler C handles the request.
Concrete Handler A handles the request.
1
2
3

在上述示例中，Handler是抽象处理者类，定义了处理请求的接口和设置后继处理者的方法。ConcreteHandlerA、ConcreteHandlerB和ConcreteHandlerC是具体处理者类，实现了处理请求的具体逻辑。
在handleRequest()方法中，每个具体处理者首先检查自己是否能够处理请求，如果可以处理则进行相应的处理；如果不能处理，则将请求传递给下一个处理者（successor），直到找到能够处理请求的处理者为止。
在main()函数中，创建了三个具体处理者对象handlerA、handlerB和handlerC，并通过调用setSuccessor()方法将它们连接成责任链。然后通过调用handleRequest()方法来发送请求，责任链会按照设置的顺序依次处理请求，直到找到能够处理请求的处理者为止。
责任链模式可以实现请求的解耦和动态的处理链。每个处理者只需要关注自己能够处理的请求，而不需要了解整个处理流程。责任链模式还可以灵活地增加、删除或修改处理者，使系统更加灵活和可扩展。