前言

模板方法、策略和职责链模式（行为型设计模式）的 C++ 代码示例模板。

代码仓库

模板方法模式（Template Method）

结构

  • 抽象类
  • 具体类
  • 抽象类 声明 步骤方法（零个或多个）（由派生类重写/实现）
  • 抽象类 定义 模板方法。形式上 调用 模板方法，实际上 调用 步骤方法。即 哪些 步骤方法 何时 调用（规定组合内容和执行时序）（抽象的模板，不变行为）
  • 具体类（零个或多个） 重写/实现 步骤方法 （具体的步骤，变化行为）
  • 抽象类指针（实际上指向一个具体类） 调用 抽象类/父类的模板方法 就是一个方案

代码

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
#include <iostream>

using std::cout;
using std::endl;

// 抽象类
class Abstraction
{
public:
    // 抽象类 定义 模板方法
    void template_method() // 形式上 调用 模板方法
    {
        cout << "template_method()" << endl;
        // 实际上 调用 步骤方法。即 哪些 步骤方法 何时 调用（规定组合内容和执行时序） （抽象的模板，不变行为）
        step_func_1();
        step_func_2();
    }

protected:
    // 抽象类 声明 步骤方法（零个或多个）（由派生类重写/实现）
    // 步骤方法1
    virtual void step_func_1() = 0;
    // 步骤方法2
    virtual void step_func_2() = 0;
};

// 具体1类
// 具体类（零个或多个） 重写/实现 步骤方法 （具体的步骤，变化行为）
class Concreteness1 : public Abstraction
{
protected:
    void step_func_1() override
    {
        cout << "Concreteness1 - step_func_1()" << endl;
    }

    void step_func_2() override
    {
        cout << "Concreteness1 - step_func_2()" << endl;
    }
};

// 具体1类
class Concreteness2 : public Abstraction
{
protected:
    void step_func_1() override
    {
        cout << "Concreteness2 - step_func_1()" << endl;
    }

    void step_func_2() override
    {
        cout << "Concreteness2 - step_func_2()" << endl;
    }
};

// 客户端
int main()
{
    // 抽象类指针（实际上指向一个具体类）
    Abstraction *abstraction_1 = new Concreteness1();
    abstraction_1->template_method(); // 抽象类指针（实际上指向一个具体类） 调用 抽象类/父类的模板方法 就是一个方案
    delete abstraction_1;

    cout << endl;

    Abstraction *abstraction_2 = new Concreteness2();
    abstraction_2->template_method();
    delete abstraction_2;

    return 0;
}
/*
输出：
template_method()
Concreteness1 - step_func_1()
Concreteness1 - step_func_2()

template_method()
Concreteness2 - step_func_1()
Concreteness2 - step_func_2()
*/

策略模式（Strategy）

结构

  • 抽象策略类
  • 具体策略类
  • 上下文类
  • 上下文类 封装 抽象策略指针（实际上指向一个具体策略对象）
  • 上下文类 封装 设置策略方法 和 执行策略方法
  • 形式上调用 上下文对象的 执行策略方法，实际上调用 具体策略对象的 执行方法

代码

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
#include <iostream>

using std::cout;
using std::endl;

// 抽象策略类
class AbstractStrategy
{
public:
    virtual void execute() = 0;
};

// 具体策略1类
class ConcreteStrategy1 : public AbstractStrategy
{
public:
    void execute() override
    {
        cout << "ConcreteStrategy1" << endl;
    }
};

// 具体策略2类
class ConcreteStrategy2 : public AbstractStrategy
{
public:
    void execute() override
    {
        cout << "ConcreteStrategy2" << endl;
    }
};

// 上下文类
// 上下文类 封装 抽象策略指针（实际上指向一个具体策略对象）
class Context
{
public:
    Context(AbstractStrategy *strategy) : strategy(strategy) {}

    // 设置策略方法
    void set_strategy(AbstractStrategy *strategy)
    {
        this->strategy = strategy;
    }

    // 执行策略方法
    void execute_strategy() // 形式上调用 上下文对象的 执行策略方法
    {
        this->strategy->execute(); // 实际上调用 具体策略对象的 执行方法
    }

private:
    AbstractStrategy *strategy;
};

// 客户端
int main()
{
    // 具体策略对象
    ConcreteStrategy1 concrete_strategy_1;
    ConcreteStrategy2 concrete_strategy_2;

    // 上下文对象
    Context context(&concrete_strategy_1); // 设置策略
    context.execute_strategy();            // 执行策略

    context.set_strategy(&concrete_strategy_2); // 设置策略
    context.execute_strategy();

    return 0;
}
/*
输出：
ConcreteStrategy1
ConcreteStrategy2
*/

职责链模式（Chain of Responsibility/CoR）

结构

  • 请求类
  • 抽象处理者类
  • 具体处理者类
  • 抽象处理者类 封装 抽象处理者指针（实际上指向一个具体处理者对象，该对象是当前具体处理对象的下一个具体处理对象/下一个处理者/继任者）
  • 抽象处理者类 封装 设置继任者方法 和 处理请求方法（如果有继任者，继任者 调用 处理请求方法处理请求；如果没有继任者，无法处理请求）
  • 具体处理者类 重写 处理请求方法（获取并判断请求的类型，如果有权处理请求，当前具体处理对象处理请求；如果无权处理请求，调用基类/抽象处理者类的处理请求方法（将请求交给继任者处理））

代码

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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
#include <iostream>

using std::cout;
using std::endl;

// 请求类
class Request
{
public:
    Request(int type) : type(type) {}

    // 获取请求的类型
    int get_type()
    {
        return this->type;
    }

private:
    int type; // 请求的类型
};

// 抽象处理者类
class AbstractHandler
{
public:
    virtual ~AbstractHandler()
    {
        delete this->successor;
    }

    // 设置继任者方法
    void set_successor(AbstractHandler *successor)
    {
        this->successor = successor;
    }

    // 处理请求方法
    virtual void handle_request(Request request)
    {
        if (this->successor != nullptr) // 如果有继任者，继任者 调用 处理请求方法处理请求
        {
            this->successor->handle_request(request);
        }
        else // 如果没有继任者，无法处理请求
        {
            cout << "Request not handled" << endl;
        }
    }

protected:
    // 抽象处理者类 封装 抽象处理者指针（实际上指向一个具体处理者对象，该对象是当前具体处理对象的下一个具体处理对象/下一个处理者/继任者）
    AbstractHandler *successor = nullptr; // 默认没有继任者
};

// 具体处理者1类
// 具体处理者类 重写 处理请求方法
class ConcreteHandler1 : public AbstractHandler
{
public:
    void handle_request(Request request) override
    {
        // 获取并判断请求的类型
        if (request.get_type() == 1) // 如果有权处理请求，当前具体处理对象处理请求
        {
            cout << "ConcreteHandler1 handles the request" << endl;
        }
        else // 如果无权处理请求，调用基类/抽象处理者类的处理请求方法（将请求交给继任者处理）
        {
            AbstractHandler::handle_request(request);
        }
    }
};

// 具体处理者2
class ConcreteHandler2 : public AbstractHandler
{
public:
    void handle_request(Request request) override
    {
        if (request.get_type() == 2)
        {
            cout << "ConcreteHandler2 handles the request" << endl;
        }
        else
        {
            AbstractHandler::handle_request(request);
        }
    }
};

// 客户端
int main()
{
    // 抽象处理者指针（实际上指向一个具体处理者对象）
    AbstractHandler *concrete_handler_1 = new ConcreteHandler1();
    AbstractHandler *concrete_handler_2 = new ConcreteHandler2();

    // 设置处理者链：concrete_handler_1 -> concrete_handler_2
    concrete_handler_1->set_successor(concrete_handler_2);

    // 请求对象
    Request request_1(1); // 1类型的请求
    Request request_2(2);
    Request request_3(3);

    // 处理请求
    concrete_handler_1->handle_request(request_1);
    concrete_handler_1->handle_request(request_2);
    concrete_handler_1->handle_request(request_3);
    // 1类型的请求，具体处理1对象有权处理
    // 2类型的请求，具体处理1对象无权处理，将请求交给继任者处理；具体处理2对象有权处理
    // 3类型的请求，具体处理1对象无权处理，将请求交给继任者处理；具体处理2对象无权处理，没有继任者；无法处理请求

    delete concrete_handler_1; // 递归析构 delete concrete_handler_2

    return 0;
}
/*
输出：
ConcreteHandler1 handles the request
ConcreteHandler2 handles the request
Request not handled
*/

总结

模板方法、策略和职责链模式（行为型设计模式）的 C++ 代码示例模板。

参考资料

作者的话

  • 感谢参考资料的作者/博主
  • 作者：夜悊
  • 版权所有，转载请注明出处，谢谢~
  • 如果文章对你有帮助，请点个赞或加个粉丝吧，你的支持就是作者的动力~
  • 文章在描述时有疑惑的地方，请留言，定会一一耐心讨论、解答
  • 文章在认识上有错误的地方, 敬请批评指正
  • 望读者们都能有所收获