设计模式概览

设计模式是解决特定问题的一系列套路，有一定的普遍性;是一套被反复使用、多数人知晓的、代码设计经验的总结。它可以提高代码的可重用性、代码的可读性和代码的可靠性以及可扩展性。

常用的设计模式有23种，5种创建型模式 (Creational Pattern)（下表中的简单工厂模式一般不算在内），7种结构型模式 (Structural Pattern)，11种行为型模式 (Behavioral Pattern)

创建型模式

结构型模式

行为型模式

简单工厂模式

定义

简单工厂模式是创建型设计模式的一种，它提供了一个创建对象的接口，但不暴露对象的创建逻辑。客户端通过一个公共的接口来创建所需的对象，而不需要知道具体的创建过程。

核心思想

• 封装对象创建过程：将对象的创建逻辑集中在一个工厂类中

• 降低耦合度：客户端不直接依赖具体的产品类

• 统一创建接口：通过工厂方法统一创建不同类型的对象

• 简化客户端代码：客户端只需要知道产品的标识，不需要了解创建细节

结构组成

1. 抽象产品 (Abstract Product)：定义产品的公共接口

2. 具体产品 (Concrete Product)：实现抽象产品接口的具体类

3. 简单工厂 (Simple Factory)：负责创建具体产品对象的工厂类

4. 客户端 (Client)：使用工厂创建产品对象

实现

形状工厂

xxxxxxxxxx
65
1
#include <iostream>
2
#include <memory>
3
#include <string>
4

5
// 抽象产品：形状接口
6
class Shape {
7
public:
8
    virtual void draw() = 0;
9
    virtual ~Shape() = default;
10
};
11

12
// 具体产品：圆形
13
class Circle : public Shape {
14
public:
15
    void draw() override {
16
        std::cout << "绘制圆形" << std::endl;
17
    }
18
};
19

20
// 具体产品：矩形
21
class Rectangle : public Shape {
22
public:
23
    void draw() override {
24
        std::cout << "绘制矩形" << std::endl;
25
    }
26
};
27

28
// 具体产品：三角形
29
class Triangle : public Shape {
30
public:
31
    void draw() override {
32
        std::cout << "绘制三角形" << std::endl;
33
    }
34
};
35

36
// 简单工厂类
37
class ShapeFactory {
38
public:
39
    static std::unique_ptr<Shape> createShape(const std::string& shapeType) {
40
        if (shapeType == "Circle") {
41
            return std::make_unique<Circle>();
42
        } else if (shapeType == "Rectangle") {
43
            return std::make_unique<Rectangle>();
44
        } else if (shapeType == "Triangle") {
45
            return std::make_unique<Triangle>();
46
        } else {
47
            return nullptr;
48
        }
49
    }
50
};
51

52
// 客户端使用
53
int main() {
54
    // 创建不同类型的形状
55
    auto circle = ShapeFactory::createShape("Circle");
56
    auto rectangle = ShapeFactory::createShape("Rectangle");
57
    auto triangle = ShapeFactory::createShape("Triangle");
58
    
59
    // 使用创建的对象
60
    if (circle) circle->draw();
61
    if (rectangle) rectangle->draw();
62
    if (triangle) triangle->draw();
63
    
64
    return 0;
65
}

数据库连接工厂

xxxxxxxxxx
31
1
class DatabaseConnection {
2
public:
3
    virtual void connect() = 0;
4
    virtual ~DatabaseConnection() = default;
5
};
6

7
class MySQLConnection : public DatabaseConnection {
8
public:
9
    void connect() override {
10
        std::cout << "连接到 MySQL 数据库" << std::endl;
11
    }
12
};
13

14
class PostgreSQLConnection : public DatabaseConnection {
15
public:
16
    void connect() override {
17
        std::cout << "连接到 PostgreSQL 数据库" << std::endl;
18
    }
19
};
20

21
class DatabaseFactory {
22
public:
23
    static std::unique_ptr<DatabaseConnection> createConnection(const std::string& dbType) {
24
        if (dbType == "MySQL") {
25
            return std::make_unique<MySQLConnection>();
26
        } else if (dbType == "PostgreSQL") {
27
            return std::make_unique<PostgreSQLConnection>();
28
        }
29
        return nullptr;
30
    }
31
};

日志记录器工厂

xxxxxxxxxx
31
1
class Logger {
2
public:
3
    virtual void log(const std::string& message) = 0;
4
    virtual ~Logger() = default;
5
};
6

7
class FileLogger : public Logger {
8
public:
9
    void log(const std::string& message) override {
10
        std::cout << "[文件日志] " << message << std::endl;
11
    }
12
};
13

14
class ConsoleLogger : public Logger {
15
public:
16
    void log(const std::string& message) override {
17
        std::cout << "[控制台日志] " << message << std::endl;
18
    }
19
};
20

21
class LoggerFactory {
22
public:
23
    static std::unique_ptr<Logger> createLogger(const std::string& loggerType) {
24
        if (loggerType == "file") {
25
            return std::make_unique<FileLogger>();
26
        } else if (loggerType == "console") {
27
            return std::make_unique<ConsoleLogger>();
28
        }
29
        return nullptr;
30
    }
31
};

总结

优缺点

优点：

1、工厂类包含必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例，客户端可以免除直接创建产品对象的职责，而仅仅“消费”产品，简单工厂模式实现了对象创建和使用的分离

2、客户端无须知道所创建的具体产品类的类名，只需要知道具体产品类所对应的参数即可，对于一些复杂的类名，通过简单工厂模式可以在一定程度减少使用者的记忆量

3、通过引入配置文件，可以在不修改任何客户端代码的情况下更换和增加新的具体产品类，在一定程度上提高了系统的灵活性。

总结：可以根据产品的名字生产出对应的产品

缺点：

1、由于工厂类集中了所有产品的创建逻辑，职责过重，一旦不能正常工作，整个系统都要受到影响；

2、使用简单工厂模式势必会增加系统中类的个数（引入新的工程类），增加了系统的复杂度和理解难度；(比如，如果想要创建梯形、椭圆形之类的图形，还需要改动Factory的代码)

3、系统拓展困难，一旦添加了新的产品就不得不修改工厂逻辑，在产品类型较多时，有可能造成工厂逻辑过于复杂，不利于系统的拓展和维护

4、简单工厂模式由于使用了静态工厂方法，造成工厂角色无法形成基于继承的等级结构

总结：违反了单一职责原则、违反了开放闭合原则、违反了依赖倒置原则

适用场景

1. 产品类型相对固定：当需要创建的对象类型不会频繁变化时

2. 客户端不关心创建过程：只需要获得产品对象，不关心如何创建

3. 创建逻辑相对简单：不涉及复杂的创建过程

4. 需要统一管理对象创建：希望将创建逻辑集中管理

简单工厂模式是最基础的工厂模式，它通过一个工厂类来创建不同类型的产品对象。虽然它违反了开闭原则，但在产品类型相对固定的场景下，简单工厂模式能够有效地封装对象创建逻辑，降低客户端与具体产品类之间的耦合度。在实际开发中，简单工厂模式常用于创建配置对象、数据库连接、日志记录器等场景。

工厂方法模式

定义

工厂方法模式是创建型设计模式的一种，它定义了一个创建对象的接口，但让子类决定实例化哪一个类。工厂方法让类的实例化推迟到子类中进行，从而实现了创建者和具体产品的解耦。

核心思想

• 延迟实例化：将对象的创建延迟到子类中决定

• 遵循开闭原则：对扩展开放，对修改关闭

• 单一职责：每个工厂类只负责创建一种产品

• 依赖倒置：依赖抽象而不是具体实现

结构组成

1. 抽象产品 (Abstract Product)：定义产品的公共接口

2. 具体产品 (Concrete Product)：实现抽象产品接口的具体类

3. 抽象工厂 (Abstract Factory)：声明工厂方法，返回抽象产品类型

4. 具体工厂 (Concrete Factory)：实现工厂方法，返回具体产品实例

5. 客户端 (Client)：使用抽象工厂和抽象产品

实现

交通工具工厂

xxxxxxxxxx
103
1
#include <iostream>
2
#include <memory>
3
#include <vector>
4

5
// 抽象产品：交通工具
6
class Vehicle {
7
public:
8
    virtual void start() = 0;
9
    virtual void stop() = 0;
10
    virtual ~Vehicle() = default;
11
};
12

13
// 具体产品：汽车
14
class Car : public Vehicle {
15
public:
16
    void start() override {
17
        std::cout << "汽车启动：点火，挂档，踩油门" << std::endl;
18
    }
19
    
20
    void stop() override {
21
        std::cout << "汽车停止：踩刹车，拉手刹" << std::endl;
22
    }
23
};
24

25
// 具体产品：自行车
26
class Bicycle : public Vehicle {
27
public:
28
    void start() override {
29
        std::cout << "自行车启动：踩踏板" << std::endl;
30
    }
31
    
32
    void stop() override {
33
        std::cout << "自行车停止：捏刹车" << std::endl;
34
    }
35
};
36

37
// 具体产品：飞机
38
class Airplane : public Vehicle {
39
public:
40
    void start() override {
41
        std::cout << "飞机启动：启动引擎，滑行起飞" << std::endl;
42
    }
43
    
44
    void stop() override {
45
        std::cout << "飞机停止：降落，关闭引擎" << std::endl;
46
    }
47
};
48

49
// 抽象工厂：交通工具工厂
50
class VehicleFactory {
51
public:
52
    virtual std::unique_ptr<Vehicle> createVehicle() = 0;
53
    virtual ~VehicleFactory() = default;
54
    
55
    // 模板方法：定义使用流程
56
    void useVehicle() {
57
        auto vehicle = createVehicle();
58
        vehicle->start();
59
        std::cout << "正在使用交通工具..." << std::endl;
60
        vehicle->stop();
61
    }
62
};
63

64
// 具体工厂：汽车工厂
65
class CarFactory : public VehicleFactory {
66
public:
67
    std::unique_ptr<Vehicle> createVehicle() override {
68
        return std::make_unique<Car>();
69
    }
70
};
71

72
// 具体工厂：自行车工厂
73
class BicycleFactory : public VehicleFactory {
74
public:
75
    std::unique_ptr<Vehicle> createVehicle() override {
76
        return std::make_unique<Bicycle>();
77
    }
78
};
79

80
// 具体工厂：飞机工厂
81
class AirplaneFactory : public VehicleFactory {
82
public:
83
    std::unique_ptr<Vehicle> createVehicle() override {
84
        return std::make_unique<Airplane>();
85
    }
86
};
87

88
// 客户端使用
89
int main() {
90
    // 创建不同的工厂
91
    std::vector<std::unique_ptr<VehicleFactory>> factories;
92
    factories.push_back(std::make_unique<CarFactory>());
93
    factories.push_back(std::make_unique<BicycleFactory>());
94
    factories.push_back(std::make_unique<AirplaneFactory>());
95
    
96
    // 使用工厂创建和使用交通工具
97
    for (auto& factory : factories) {
98
        factory->useVehicle();
99
        std::cout << "-------------------" << std::endl;
100
    }
101
    
102
    return 0;
103
}

数据库连接工厂

xxxxxxxxxx
63
1
// 抽象产品：数据库连接
2
class DatabaseConnection {
3
public:
4
    virtual void connect() = 0;
5
    virtual void executeQuery(const std::string& sql) = 0;
6
    virtual void disconnect() = 0;
7
    virtual ~DatabaseConnection() = default;
8
};
9

10
// 具体产品：MySQL连接
11
class MySQLConnection : public DatabaseConnection {
12
public:
13
    void connect() override {
14
        std::cout << "连接到MySQL数据库" << std::endl;
15
    }
16
    
17
    void executeQuery(const std::string& sql) override {
18
        std::cout << "在MySQL中执行: " << sql << std::endl;
19
    }
20
    
21
    void disconnect() override {
22
        std::cout << "断开MySQL连接" << std::endl;
23
    }
24
};
25

26
// 具体产品：PostgreSQL连接
27
class PostgreSQLConnection : public DatabaseConnection {
28
public:
29
    void connect() override {
30
        std::cout << "连接到PostgreSQL数据库" << std::endl;
31
    }
32
    
33
    void executeQuery(const std::string& sql) override {
34
        std::cout << "在PostgreSQL中执行: " << sql << std::endl;
35
    }
36
    
37
    void disconnect() override {
38
        std::cout << "断开PostgreSQL连接" << std::endl;
39
    }
40
};
41

42
// 抽象工厂：数据库工厂
43
class DatabaseFactory {
44
public:
45
    virtual std::unique_ptr<DatabaseConnection> createConnection() = 0;
46
    virtual ~DatabaseFactory() = default;
47
};
48

49
// 具体工厂：MySQL工厂
50
class MySQLFactory : public DatabaseFactory {
51
public:
52
    std::unique_ptr<DatabaseConnection> createConnection() override {
53
        return std::make_unique<MySQLConnection>();
54
    }
55
};
56

57
// 具体工厂：PostgreSQL工厂
58
class PostgreSQLFactory : public DatabaseFactory {
59
public:
60
    std::unique_ptr<DatabaseConnection> createConnection() override {
61
        return std::make_unique<PostgreSQLConnection>();
62
    }
63
};

日志记录器工厂

xxxxxxxxxx
59
1
// 抽象产品：日志记录器
2
class Logger {
3
public:
4
    virtual void log(const std::string& message) = 0;
5
    virtual ~Logger() = default;
6
};
7

8
// 具体产品：文件日志记录器
9
class FileLogger : public Logger {
10
public:
11
    void log(const std::string& message) override {
12
        std::cout << "[文件日志] " << message << std::endl;
13
    }
14
};
15

16
// 具体产品：控制台日志记录器
17
class ConsoleLogger : public Logger {
18
public:
19
    void log(const std::string& message) override {
20
        std::cout << "[控制台日志] " << message << std::endl;
21
    }
22
};
23

24
// 具体产品：网络日志记录器
25
class NetworkLogger : public Logger {
26
public:
27
    void log(const std::string& message) override {
28
        std::cout << "[网络日志] " << message << std::endl;
29
    }
30
};
31

32
// 抽象工厂：日志工厂
33
class LoggerFactory {
34
public:
35
    virtual std::unique_ptr<Logger> createLogger() = 0;
36
    virtual ~LoggerFactory() = default;
37
};
38

39
// 具体工厂实现
40
class FileLoggerFactory : public LoggerFactory {
41
public:
42
    std::unique_ptr<Logger> createLogger() override {
43
        return std::make_unique<FileLogger>();
44
    }
45
};
46

47
class ConsoleLoggerFactory : public LoggerFactory {
48
public:
49
    std::unique_ptr<Logger> createLogger() override {
50
        return std::make_unique<ConsoleLogger>();
51
    }
52
};
53

54
class NetworkLoggerFactory : public LoggerFactory {
55
public:
56
    std::unique_ptr<Logger> createLogger() override {
57
        return std::make_unique<NetworkLogger>();
58
    }
59
};

总结

优缺点

优点：

1、用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程。

2、灵活性增强，对于新产品的创建，只需多写一个相应的工厂类。

3、典型的解耦框架。高层模块只需要知道产品的抽象类，无须关心其他实现类。

4、对扩展开放对修改关闭；解决了简单工厂的缺点问题。

总结：遵循了单一职责原则、开放闭合原则、遵循了依赖倒置原则。

缺点：

1、类的个数容易过多，增加复杂度

2、增加了系统的抽象性和理解难度

3、接口的传入参数类型需要一致，且只能对单一变化量接口使用

4、抽象产品只能生产一种产品，此弊端可使用抽象工厂模式解决。

总结：工厂的数量会随着产品的增加而急剧上升。

适用场景

1. 创建对象需要大量重复代码

2. 客户端不依赖于产品类实例如何被创建、实现等细节

3. 一个类通过其子类来指定创建哪个对象

4. 需要为库或框架提供扩展点

与简单工厂模式的区别

工厂方法模式是一种非常实用的创建型设计模式，它通过将对象的创建延迟到子类中，实现了创建者和产品的解耦。相比简单工厂模式，工厂方法模式更好地遵循了开闭原则和单一职责原则，使得系统更容易扩展和维护。在需要创建多种相关产品，且产品种类可能会增加的场景下，工厂方法模式是一个很好的选择。

抽象工厂模式

定义

抽象工厂模式是创建型设计模式的一种，它提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。抽象工厂模式也被称为Kit模式，它是工厂方法模式的进一步抽象和推广。

核心思想

• 产品族概念：创建一系列相关的产品对象

• 多个工厂方法：一个抽象工厂包含多个工厂方法

• 产品一致性：确保同一工厂创建的产品属于同一产品族

• 易于切换产品族：通过切换工厂来切换整个产品族

结构组成

1. 抽象工厂 (Abstract Factory)：声明创建抽象产品对象的操作接口

2. 具体工厂 (Concrete Factory)：实现创建具体产品对象的操作

3. 抽象产品 (Abstract Product)：为一类产品对象声明接口

4. 具体产品 (Concrete Product)：定义具体工厂创建的产品对象

5. 客户端 (Client)：使用抽象工厂和抽象产品类声明的接口

产品族概念

产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品。例如：

• 现代风格家具族：现代沙发 + 现代茶几 + 现代衣柜

• 古典风格家具族：古典沙发 + 古典茶几 + 古典衣柜

实现

GUI组件工厂

xxxxxxxxxx
249
1
#include <iostream>
2
#include <memory>
3

4
// 抽象产品A：按钮
5
class Button {
6
public:
7
    virtual void render() = 0;
8
    virtual void onClick() = 0;
9
    virtual ~Button() = default;
10
};
11

12
// 抽象产品B：文本框
13
class TextBox {
14
public:
15
    virtual void render() = 0;
16
    virtual void input(const std::string& text) = 0;
17
    virtual ~TextBox() = default;
18
};
19

20
// 抽象产品C：复选框
21
class CheckBox {
22
public:
23
    virtual void render() = 0;
24
    virtual void toggle() = 0;
25
    virtual ~CheckBox() = default;
26
};
27

28
// Windows风格的具体产品
29
class WindowsButton : public Button {
30
public:
31
    void render() override {
32
        std::cout << "渲染Windows风格按钮" << std::endl;
33
    }
34
    
35
    void onClick() override {
36
        std::cout << "Windows按钮被点击" << std::endl;
37
    }
38
};
39

40
class WindowsTextBox : public TextBox {
41
public:
42
    void render() override {
43
        std::cout << "渲染Windows风格文本框" << std::endl;
44
    }
45
    
46
    void input(const std::string& text) override {
47
        std::cout << "Windows文本框输入: " << text << std::endl;
48
    }
49
};
50

51
class WindowsCheckBox : public CheckBox {
52
public:
53
    void render() override {
54
        std::cout << "渲染Windows风格复选框" << std::endl;
55
    }
56
    
57
    void toggle() override {
58
        std::cout << "Windows复选框状态切换" << std::endl;
59
    }
60
};
61

62
// macOS风格的具体产品
63
class MacButton : public Button {
64
public:
65
    void render() override {
66
        std::cout << "渲染macOS风格按钮" << std::endl;
67
    }
68
    
69
    void onClick() override {
70
        std::cout << "macOS按钮被点击" << std::endl;
71
    }
72
};
73

74
class MacTextBox : public TextBox {
75
public:
76
    void render() override {
77
        std::cout << "渲染macOS风格文本框" << std::endl;
78
    }
79
    
80
    void input(const std::string& text) override {
81
        std::cout << "macOS文本框输入: " << text << std::endl;
82
    }
83
};
84

85
class MacCheckBox : public CheckBox {
86
public:
87
    void render() override {
88
        std::cout << "渲染macOS风格复选框" << std::endl;
89
    }
90
    
91
    void toggle() override {
92
        std::cout << "macOS复选框状态切换" << std::endl;
93
    }
94
};
95

96
// Linux风格的具体产品
97
class LinuxButton : public Button {
98
public:
99
    void render() override {
100
        std::cout << "渲染Linux风格按钮" << std::endl;
101
    }
102
    
103
    void onClick() override {
104
        std::cout << "Linux按钮被点击" << std::endl;
105
    }
106
};
107

108
class LinuxTextBox : public TextBox {
109
public:
110
    void render() override {
111
        std::cout << "渲染Linux风格文本框" << std::endl;
112
    }
113
    
114
    void input(const std::string& text) override {
115
        std::cout << "Linux文本框输入: " << text << std::endl;
116
    }
117
};
118

119
class LinuxCheckBox : public CheckBox {
120
public:
121
    void render() override {
122
        std::cout << "渲染Linux风格复选框" << std::endl;
123
    }
124
    
125
    void toggle() override {
126
        std::cout << "Linux复选框状态切换" << std::endl;
127
    }
128
};
129

130
// 抽象工厂
131
class GUIFactory {
132
public:
133
    virtual std::unique_ptr<Button> createButton() = 0;
134
    virtual std::unique_ptr<TextBox> createTextBox() = 0;
135
    virtual std::unique_ptr<CheckBox> createCheckBox() = 0;
136
    virtual ~GUIFactory() = default;
137
};
138

139
// 具体工厂：Windows工厂
140
class WindowsFactory : public GUIFactory {
141
public:
142
    std::unique_ptr<Button> createButton() override {
143
        return std::make_unique<WindowsButton>();
144
    }
145
    
146
    std::unique_ptr<TextBox> createTextBox() override {
147
        return std::make_unique<WindowsTextBox>();
148
    }
149
    
150
    std::unique_ptr<CheckBox> createCheckBox() override {
151
        return std::make_unique<WindowsCheckBox>();
152
    }
153
};
154

155
// 具体工厂：macOS工厂
156
class MacFactory : public GUIFactory {
157
public:
158
    std::unique_ptr<Button> createButton() override {
159
        return std::make_unique<MacButton>();
160
    }
161
    
162
    std::unique_ptr<TextBox> createTextBox() override {
163
        return std::make_unique<MacTextBox>();
164
    }
165
    
166
    std::unique_ptr<CheckBox> createCheckBox() override {
167
        return std::make_unique<MacCheckBox>();
168
    }
169
};
170

171
// 具体工厂：Linux工厂
172
class LinuxFactory : public GUIFactory {
173
public:
174
    std::unique_ptr<Button> createButton() override {
175
        return std::make_unique<LinuxButton>();
176
    }
177
    
178
    std::unique_ptr<TextBox> createTextBox() override {
179
        return std::make_unique<LinuxTextBox>();
180
    }
181
    
182
    std::unique_ptr<CheckBox> createCheckBox() override {
183
        return std::make_unique<LinuxCheckBox>();
184
    }
185
};
186

187
// 客户端应用程序
188
class Application {
189
public:
190
    Application(std::unique_ptr<GUIFactory> factory) 
191
        : factory_(std::move(factory)) {
192
        createUI();
193
    }
194
    
195
    void createUI() {
196
        button_ = factory_->createButton();
197
        textBox_ = factory_->createTextBox();
198
        checkBox_ = factory_->createCheckBox();
199
    }
200
    
201
    void renderUI() {
202
        button_->render();
203
        textBox_->render();
204
        checkBox_->render();
205
    }
206
    
207
    void interactWithUI() {
208
        button_->onClick();
209
        textBox_->input("Hello World");
210
        checkBox_->toggle();
211
    }
212
    
213
private:
214
    std::unique_ptr<GUIFactory> factory_;
215
    std::unique_ptr<Button> button_;
216
    std::unique_ptr<TextBox> textBox_;
217
    std::unique_ptr<CheckBox> checkBox_;
218
};
219

220
// 工厂选择器
221
std::unique_ptr<GUIFactory> createFactory(const std::string& platform) {
222
    if (platform == "Windows") {
223
        return std::make_unique<WindowsFactory>();
224
    } else if (platform == "macOS") {
225
        return std::make_unique<MacFactory>();
226
    } else if (platform == "Linux") {
227
        return std::make_unique<LinuxFactory>();
228
    }
229
    return nullptr;
230
}
231

232
// 使用示例
233
int main() {
234
    // 根据平台创建对应的工厂
235
    std::string platform = "Windows"; // 可以从配置文件或环境变量获取
236
    
237
    auto factory = createFactory(platform);
238
    if (factory) {
239
        Application app(std::move(factory));
240
        
241
        std::cout << "=== 渲染UI ===" << std::endl;
242
        app.renderUI();
243
        
244
        std::cout << "\n=== 交互操作 ===" << std::endl;
245
        app.interactWithUI();
246
    }
247
    
248
    return 0;
249
}

游戏角色装备工厂

xxxxxxxxxx
245
1
#include <iostream>
2
#include <memory>
3
#include <vector>
4

5
// 抽象产品：武器
6
class Weapon {
7
public:
8
    virtual void attack() = 0;
9
    virtual int getDamage() const = 0;
10
    virtual ~Weapon() = default;
11
};
12

13
// 抽象产品：护甲
14
class Armor {
15
public:
16
    virtual void defend() = 0;
17
    virtual int getDefense() const = 0;
18
    virtual ~Armor() = default;
19
};
20

21
// 抽象产品：饰品
22
class Accessory {
23
public:
24
    virtual void useSpecialAbility() = 0;
25
    virtual std::string getEffect() const = 0;
26
    virtual ~Accessory() = default;
27
};
28

29
// 战士装备族
30
class WarriorSword : public Weapon {
31
public:
32
    void attack() override {
33
        std::cout << "挥舞战士之剑进行强力攻击!" << std::endl;
34
    }
35
    
36
    int getDamage() const override { return 100; }
37
};
38

39
class WarriorArmor : public Armor {
40
public:
41
    void defend() override {
42
        std::cout << "战士重甲提供强大防护!" << std::endl;
43
    }
44
    
45
    int getDefense() const override { return 80; }
46
};
47

48
class WarriorShield : public Accessory {
49
public:
50
    void useSpecialAbility() override {
51
        std::cout << "举起盾牌，格挡敌人攻击!" << std::endl;
52
    }
53
    
54
    std::string getEffect() const override { return "格挡+50%"; }
55
};
56

57
// 法师装备族
58
class MageStaff : public Weapon {
59
public:
60
    void attack() override {
61
        std::cout << "挥舞法师法杖释放魔法攻击!" << std::endl;
62
    }
63
    
64
    int getDamage() const override { return 120; }
65
};
66

67
class MageRobe : public Armor {
68
public:
69
    void defend() override {
70
        std::cout << "法师长袍提供魔法防护!" << std::endl;
71
    }
72
    
73
    int getDefense() const override { return 40; }
74
};
75

76
class MageOrb : public Accessory {
77
public:
78
    void useSpecialAbility() override {
79
        std::cout << "魔法球增强法术威力!" << std::endl;
80
    }
81
    
82
    std::string getEffect() const override { return "魔法伤害+30%"; }
83
};
84

85
// 盗贼装备族
86
class RogueDagger : public Weapon {
87
public:
88
    void attack() override {
89
        std::cout << "使用盗贼匕首进行快速攻击!" << std::endl;
90
    }
91
    
92
    int getDamage() const override { return 80; }
93
};
94

95
class RogueLeather : public Armor {
96
public:
97
    void defend() override {
98
        std::cout << "盗贼皮甲提供灵活防护!" << std::endl;
99
    }
100
    
101
    int getDefense() const override { return 50; }
102
};
103

104
class RogueCloak : public Accessory {
105
public:
106
    void useSpecialAbility() override {
107
        std::cout << "隐身斗篷让你消失在阴影中!" << std::endl;
108
    }
109
    
110
    std::string getEffect() const override { return "隐身5秒"; }
111
};
112

113
// 抽象装备工厂
114
class EquipmentFactory {
115
public:
116
    virtual std::unique_ptr<Weapon> createWeapon() = 0;
117
    virtual std::unique_ptr<Armor> createArmor() = 0;
118
    virtual std::unique_ptr<Accessory> createAccessory() = 0;
119
    virtual std::string getClassName() const = 0;
120
    virtual ~EquipmentFactory() = default;
121
};
122

123
// 具体工厂：战士装备工厂
124
class WarriorEquipmentFactory : public EquipmentFactory {
125
public:
126
    std::unique_ptr<Weapon> createWeapon() override {
127
        return std::make_unique<WarriorSword>();
128
    }
129
    
130
    std::unique_ptr<Armor> createArmor() override {
131
        return std::make_unique<WarriorArmor>();
132
    }
133
    
134
    std::unique_ptr<Accessory> createAccessory() override {
135
        return std::make_unique<WarriorShield>();
136
    }
137
    
138
    std::string getClassName() const override { return "战士"; }
139
};
140

141
// 具体工厂：法师装备工厂
142
class MageEquipmentFactory : public EquipmentFactory {
143
public:
144
    std::unique_ptr<Weapon> createWeapon() override {
145
        return std::make_unique<MageStaff>();
146
    }
147
    
148
    std::unique_ptr<Armor> createArmor() override {
149
        return std::make_unique<MageRobe>();
150
    }
151
    
152
    std::unique_ptr<Accessory> createAccessory() override {
153
        return std::make_unique<MageOrb>();
154
    }
155
    
156
    std::string getClassName() const override { return "法师"; }
157
};
158

159
// 具体工厂：盗贼装备工厂
160
class RogueEquipmentFactory : public EquipmentFactory {
161
public:
162
    std::unique_ptr<Weapon> createWeapon() override {
163
        return std::make_unique<RogueDagger>();
164
    }
165
    
166
    std::unique_ptr<Armor> createArmor() override {
167
        return std::make_unique<RogueLeather>();
168
    }
169
    
170
    std::unique_ptr<Accessory> createAccessory() override {
171
        return std::make_unique<RogueCloak>();
172
    }
173
    
174
    std::string getClassName() const override { return "盗贼"; }
175
};
176

177
// 游戏角色类
178
class GameCharacter {
179
public:
180
    GameCharacter(std::unique_ptr<EquipmentFactory> factory)
181
        : factory_(std::move(factory)) {
182
        equipItems();
183
    }
184
    
185
    void equipItems() {
186
        weapon_ = factory_->createWeapon();
187
        armor_ = factory_->createArmor();
188
        accessory_ = factory_->createAccessory();
189
        
190
        std::cout << "=== " << factory_->getClassName() << "装备完成 ===" << std::endl;
191
    }
192
    
193
    void showStats() {
194
        std::cout << "职业: " << factory_->getClassName() << std::endl;
195
        std::cout << "攻击力: " << weapon_->getDamage() << std::endl;
196
        std::cout << "防御力: " << armor_->getDefense() << std::endl;
197
        std::cout << "特殊效果: " << accessory_->getEffect() << std::endl;
198
    }
199
    
200
    void performActions() {
201
        weapon_->attack();
202
        armor_->defend();
203
        accessory_->useSpecialAbility();
204
    }
205
    
206
private:
207
    std::unique_ptr<EquipmentFactory> factory_;
208
    std::unique_ptr<Weapon> weapon_;
209
    std::unique_ptr<Armor> armor_;
210
    std::unique_ptr<Accessory> accessory_;
211
};
212

213
// 角色创建器
214
class CharacterCreator {
215
public:
216
    static std::unique_ptr<EquipmentFactory> createEquipmentFactory(const std::string& characterClass) {
217
        if (characterClass == "Warrior") {
218
            return std::make_unique<WarriorEquipmentFactory>();
219
        } else if (characterClass == "Mage") {
220
            return std::make_unique<MageEquipmentFactory>();
221
        } else if (characterClass == "Rogue") {
222
            return std::make_unique<RogueEquipmentFactory>();
223
        }
224
        return nullptr;
225
    }
226
};
227

228
// 使用示例
229
int main() {
230
    std::vector<std::string> characterClasses = {"Warrior", "Mage", "Rogue"};
231
    
232
    for (const auto& characterClass : characterClasses) {
233
        auto factory = CharacterCreator::createEquipmentFactory(characterClass);
234
        if (factory) {
235
            GameCharacter character(std::move(factory));
236
            
237
            character.showStats();
238
            std::cout << "\n=== 战斗演示 ===" << std::endl;
239
            character.performActions();
240
            std::cout << "\n" << std::string(40, '-') << "\n" << std::endl;
241
        }
242
    }
243
    
244
    return 0;
245
}

总结

优缺点

优点：

1. 抽象工厂模式隔离了具体类的生成，使得客户端并不需要知道什么被创建。

2. 当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一产品族中的对象；

3. 增加新的产品族很方便（生成新的具体工厂），无需修改已有系统代码，符合开闭原则；

缺点： 增加新的产品等级结构很复杂，需要修改抽象工厂和所有的具体工厂类，对“开闭原则”的支持呈现倾斜性。

适用场景

1. 系统需要独立于产品的创建、组合和表示

2. 系统需要由多个产品族中的一个来配置

3. 需要强调一系列相关产品对象的设计以便进行联合使用

4. 提供一个产品类库，只想显示接口而不是实现

与其他工厂模式的对比

实际应用场景

1. 跨平台UI框架：不同操作系统的UI组件

2. 数据库访问层：不同数据库的连接、命令、事务对象

3. 游戏开发：不同职业的装备、技能、属性

4. 主题系统：不同主题的颜色、字体、图标

5. 文档处理：不同格式的解析器、生成器、验证器

抽象工厂模式是处理产品族创建的强大工具，它通过提供一系列相关产品的创建接口，确保了产品的一致性和系统的可扩展性。虽然它增加了系统的复杂度，但在需要管理多个相关产品族的场景下，抽象工厂模式能够提供清晰的架构和良好的可维护性。在实际应用中，合理地设计产品族和工厂层次结构是成功应用这一模式的关键。

观察者模式

定义

观察者模式是一种行为型设计模式，它定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。

核心思想

• 发布-订阅机制：主题（Subject）维护一个观察者列表，状态改变时通知所有观察者

• 松耦合：主题和观察者之间通过抽象接口交互，降低耦合度

• 动态关系：观察者可以在运行时动态添加或移除

• 广播通信：一个主题可以同时通知多个观察者

结构组成

1. 抽象主题（Subject）

定义添加、删除和通知观察者的接口

2. 具体主题（ConcreteSubject）

实现抽象主题接口，维护观察者列表和状态

3. 抽象观察者（Observer）

定义更新接口，供主题通知时调用

4. 具体观察者（ConcreteObserver）

实现抽象观察者接口，定义具体的更新行为

实现

基础实现

xxxxxxxxxx
93
1
#include <iostream>
2
#include <vector>
3
#include <algorithm>
4
#include <string>
5

6
// 抽象观察者
7
class Observer {
8
public:
9
    virtual ~Observer() = default;
10
    virtual void update(const std::string& message) = 0;
11
};
12

13
// 抽象主题
14
class Subject {
15
public:
16
    virtual ~Subject() = default;
17
    virtual void attach(Observer* observer) = 0;
18
    virtual void detach(Observer* observer) = 0;
19
    virtual void notify() = 0;
20
};
21

22
// 具体主题 - 新闻发布者
23
class NewsPublisher : public Subject {
24
private:
25
    std::vector<Observer*> observers;
26
    std::string news;
27
    
28
public:
29
    void attach(Observer* observer) override {
30
        observers.push_back(observer);
31
    }
32
    
33
    void detach(Observer* observer) override {
34
        observers.erase(
35
            std::remove(observers.begin(), observers.end(), observer),
36
            observers.end()
37
        );
38
    }
39
    
40
    void notify() override {
41
        for (auto* observer : observers) {
42
            observer->update(news);
43
        }
44
    }
45
    
46
    void setNews(const std::string& newNews) {
47
        news = newNews;
48
        notify();
49
    }
50
    
51
    std::string getNews() const {
52
        return news;
53
    }
54
};
55

56
// 具体观察者 - 新闻订阅者
57
class NewsSubscriber : public Observer {
58
private:
59
    std::string name;
60
    
61
public:
62
    NewsSubscriber(const std::string& subscriberName) 
63
        : name(subscriberName) {}
64
    
65
    void update(const std::string& message) override {
66
        std::cout << "订阅者 " << name << " 收到新闻: " << message << std::endl;
67
    }
68
};
69

70
// 使用示例
71
int main() {
72
    NewsPublisher publisher;
73
    
74
    NewsSubscriber subscriber1("张三");
75
    NewsSubscriber subscriber2("李四");
76
    NewsSubscriber subscriber3("王五");
77
    
78
    // 订阅新闻
79
    publisher.attach(&subscriber1);
80
    publisher.attach(&subscriber2);
81
    publisher.attach(&subscriber3);
82
    
83
    // 发布新闻
84
    publisher.setNews("重大科技突破！");
85
    
86
    std::cout << "\n--- 李四取消订阅 ---\n" << std::endl;
87
    publisher.detach(&subscriber2);
88
    
89
    // 再次发布新闻
90
    publisher.setNews("经济形势分析报告发布");
91
    
92
    return 0;
93
}