简述设计模式七大原则
- 单一职责原则：一个类、接口或方法只负责一个职责。将不同功能模块独立封装。
- 开闭原则：对扩展开放，对修改关闭。通过继承或接口（抽象类）实现功能扩展，不直接修改已有代码。
- 里氏替换原则：子类对象必须能够替换父类对象而不影响程序行为。子类重写方法时避免违反接口预期。
- 依赖倒置原则：针对接口编程，依赖于抽象类或接口而不依赖于具体实现类。
- 接口隔离原则：将不同功能定义在不同接口中，实现接口隔离。
- 合成复用原则：尽量使用组合(has-a)/聚合(contains-a)而不是继承(is-a)来实现软件复用。
- 迪米特原则：每个模块对其他模块都要尽可能少地了解和依赖，降低代码耦合度。
简述设计模式的分类
- 创建型模式：解决“对象怎么创建”。在创建对象的同时隐藏创建逻辑，不使用 new 直接实例化对象。
- 工厂方法模式
- 抽象工厂模式
- 单例模式
- 建造者模式
- 原型模式
- 结构型模式：解决“类与对象如何组合”。通过类和接口间的继承和引用实现创建复杂结构的对象。
- 适配器模式
- 装饰器模式
- 代理模式
- 外观模式
- 桥接模式
- 组合模式
- 享元模式
- 行为型模式：解决“对象如何协作、分配职责”。通过类之间不同通信方式实现不同行为。
- 策略模式
- 模板方法模式
- 观察者模式
- 迭代器模式
- 责任链模式
- 命令模式
- 备忘录模式
- 状态模式
- 访问者模式
- 中介者模式
- 解释器模式
简述简单工厂模式
简单工厂模式指由一个工厂类根据参数来创建实例。适用于工厂类负责创建对象较少的情况。
1#include <iostream>
2#include <memory>
3#include <string>
4
5// 抽象产品
6class Shape {
7public:
8 virtual void draw() = 0; // 纯虚函数 抽象接口 派生类必须实现
9 virtual ~Shape() = default; // 基类的析构函数应为虚函数 使用默认生成的函数实现
10};
11
12// 具体产品
13class Circle : public Shape {
14public:
15 void draw() override { std::cout << "Draw Circle\n"; }
16};
17
18class Rectangle : public Shape {
19public:
20 void draw() override { std::cout << "Draw Rectangle\n"; }
21};
22
23// 工厂类
24class ShapeFactory {
25public:
26 static std::unique_ptr<Shape> createShape(const std::string &type)
27 {
28 if (type == "circle") return std::make_unique<Circle>();
29 if (type == "rectangle") return std::make_unique<Rectangle>();
30 return nullptr;
31 }
32};
33
34int main()
35{
36 auto list = {"circle", "rectangle", "triangle"};
37 for (const auto &type : list) {
38 auto shape = ShapeFactory::createShape(type);
39 if (shape) shape->draw();
40 else std::cout << "Unknown shape type: " << type << "\n";
41 }
42 return 0;
43}简述工厂模式
工厂方法模式：将类的实例化推迟到子类。定义一个创建对象的接口，让接口的实现类决定创建哪种对象。常用于插件系统、跨平台抽象、策略可扩展模块。
优点
- 符合 开闭原则，扩展新产品无需修改已有工厂或客户端代码。
- 客户端只依赖抽象接口，解耦明确。
缺点
- 工厂类增加，类的数量较多（尤其产品种类多时）。
- 相对简单工厂，使用更复杂，需要更多类的管理。
1#include <iostream>
2#include <memory>
3#include <string>
4
5// 抽象产品
6class Shape {
7public:
8 virtual void draw() = 0;
9 virtual ~Shape() = default;
10};
11
12// 具体产品
13class Circle : public Shape {
14public:
15 void draw() override { std::cout << "Draw Circle\n"; }
16};
17
18class Rectangle : public Shape {
19public:
20 void draw() override { std::cout << "Draw Rectangle\n"; }
21};
22
23// 抽象工厂
24class ShapeFactory {
25public:
26 virtual std::unique_ptr<Shape> createShape() = 0;
27 virtual ~ShapeFactory() = default;
28};
29
30// 具体工厂
31class CircleFactory : public ShapeFactory {
32public:
33 std::unique_ptr<Shape> createShape() override
34 {
35 return std::make_unique<Circle>();
36 }
37};
38
39class RectangleFactory : public ShapeFactory {
40public:
41 std::unique_ptr<Shape> createShape() override
42 {
43 return std::make_unique<Rectangle>();
44 }
45};
46
47// 工厂选择函数
48std::unique_ptr<ShapeFactory> createFactory(const std::string& type)
49{
50 if (type == "circle") return std::make_unique<CircleFactory>();
51 if (type == "rectangle") return std::make_unique<RectangleFactory>();
52 return nullptr;
53}
54
55int main()
56{
57 auto shapeTypes = {"circle", "rectangle", "triangle"};
58
59 for (const auto& type : shapeTypes) {
60 auto factory = createFactory(type);
61 if (factory) {
62 auto shape = factory->createShape();
63 shape->draw();
64 }
65 else {
66 std::cout << "Unknown shape type: " << type << "\n";
67 }
68 }
69
70 return 0;
71}简述抽象工厂模式
抽象工厂：提供一个接口，用于创建一系列相关或相互依赖对象，而无需指定它们的具体类。
1#include <iostream>
2#include <memory>
3
4// 抽象产品
5class Shape {
6public:
7 virtual void draw() = 0;
8 virtual ~Shape() = default;
9};
10
11class Color {
12public:
13 virtual void fill() = 0;
14 virtual ~Color() = default;
15};
16
17// 具体产品
18class Circle : public Shape {
19public:
20 void draw() override { std::cout << "Draw Circle\n"; }
21};
22
23class Rectangle : public Shape {
24public:
25 void draw() override { std::cout << "Draw Rectangle\n"; }
26};
27
28class Red : public Color {
29public:
30 void fill() override { std::cout << "Fill Red\n"; }
31};
32
33class Blue : public Color {
34public:
35 void fill() override { std::cout << "Fill Blue\n"; }
36};
37
38// 抽象工厂
39class AbstractFactory {
40public:
41 virtual std::unique_ptr<Shape> createShape() = 0;
42 virtual std::unique_ptr<Color> createColor() = 0;
43 virtual ~AbstractFactory() = default;
44};
45
46// 具体工厂 1：生产红色产品族
47class RedFactory : public AbstractFactory {
48public:
49 std::unique_ptr<Shape> createShape() override { return std::make_unique<Circle>(); }
50 std::unique_ptr<Color> createColor() override { return std::make_unique<Red>(); }
51};
52
53// 具体工厂 2：生产蓝色产品族
54class BlueFactory : public AbstractFactory {
55public:
56 std::unique_ptr<Shape> createShape() override { return std::make_unique<Rectangle>(); }
57 std::unique_ptr<Color> createColor() override { return std::make_unique<Blue>(); }
58};
59
60// 如果产品族组合多，具体工厂类会呈指数级增长，编码复杂，扩展不太方便。
61
62int main()
63{
64 std::unique_ptr<AbstractFactory> factory = std::make_unique<RedFactory>();
65 auto shape = factory->createShape();
66 auto color = factory->createColor();
67 shape->draw(); // Draw Circle
68 color->fill(); // Fill Red
69
70 factory = std::make_unique<BlueFactory>();
71 shape = factory->createShape();
72 color = factory->createColor();
73 shape->draw(); // Draw Rectangle
74 color->fill(); // Fill Blue
75
76 return 0;
77}简述注册工厂模式
注册工厂模式：工厂方法模式的扩展，允许在运行时通过 注册机制 动态创建对象，而无需修改工厂或客户端代码。适用于插件系统、动态加载模块等场景。
1#include <iostream>
2#include <memory>
3#include <string>
4#include <unordered_map>
5#include <functional>
6
7// 抽象产品
8class Shape {
9public:
10 virtual void draw() = 0;
11 virtual ~Shape() = default;
12};
13
14// 具体产品
15class Circle : public Shape {
16public:
17 void draw() override { std::cout << "Draw Circle\n"; }
18};
19
20class Rectangle : public Shape {
21public:
22 void draw() override { std::cout << "Draw Rectangle\n"; }
23};
24
25// 注册工厂
26class ShapeFactory {
27public:
28 using Creator = std::function<std::unique_ptr<Shape>()>;
29
30 static void registerShape(const std::string& name, Creator creator)
31 {
32 getRegistry()[name] = creator;
33 }
34
35 static std::unique_ptr<Shape> createShape(const std::string& name)
36 {
37 auto it = getRegistry().find(name);
38 if (it != getRegistry().end()) {
39 return it->second();
40 }
41 return nullptr;
42 }
43
44private:
45 // 局部静态变量 避免初始化顺序问题
46 static std::unordered_map<std::string, Creator>& getRegistry()
47 {
48 static std::unordered_map<std::string, Creator> registry;
49 return registry;
50 }
51};
52
53// 注册产品
54void registerShapes()
55{
56 ShapeFactory::registerShape("circle", []() { return std::make_unique<Circle>(); });
57 ShapeFactory::registerShape("rectangle", []() { return std::make_unique<Rectangle>(); });
58}
59
60int main()
61{
62 registerShapes();
63 std::string shapeTypes[] = {"circle", "rectangle", "triangle"};
64
65 for (const auto& type : shapeTypes) {
66 auto shape = ShapeFactory::createShape(type);
67 if (shape) {
68 shape->draw();
69 }
70 else {
71 std::cout << "Unknown shape type: " << type << "\n";
72 }
73 }
74
75 return 0;
76}简述单例模式
一个单例类在任何情况下都只存在一个实例。
饿汉式
饿汉式在类加载时就创建实例，写法简单，线程安全，但无法延迟初始化，可能浪费资源。
1class EagerSingleton {
2public:
3 EagerSingleton(const EagerSingleton&) = delete; // 删除 拷贝构造函数
4 EagerSingleton& operator=(const EagerSingleton&) = delete; // 删除 赋值运算符
5 ~EagerSingleton() = default; // 默认 析构函数
6
7 static EagerSingleton& getInstance()
8 {
9 return instance;
10 }
11
12private:
13 EagerSingleton() = default; // 私有 构造函数，禁止外部实例化
14 static EagerSingleton instance;
15};
16EagerSingleton EagerSingleton::instance;懒汉式
基础版本
线程不安全
1class LazySingleton {
2public:
3 LazySingleton(const LazySingleton&) = delete; // 删除 拷贝构造函数
4 LazySingleton& operator=(const LazySingleton&) = delete; // 删除 赋值运算符
5 ~LazySingleton() = default; // 默认 析构函数
6
7 static LazySingleton* getInstance()
8 {
9 // TODO 线程不安全
10 if (instance == nullptr) {
11 instance = new LazySingleton(); // 延迟实例化
12 }
13 return instance;
14 }
15
16private:
17 LazySingleton() = default; // 私有 构造函数，禁止外部实例化
18 static LazySingleton* instance;
19};
20LazySingleton* LazySingleton::instance = nullptr;双重检查锁定
1
2class DoubleCheckSingleton {
3public:
4 DoubleCheckSingleton(const DoubleCheckSingleton&) = delete; // 删除 拷贝构造函数
5 DoubleCheckSingleton& operator=(const DoubleCheckSingleton&) = delete; // 删除 赋值运算符
6 ~DoubleCheckSingleton() = default; // 默认 析构函数 但从未调用
7
8#if 1
9 static DoubleCheckSingleton* getInstance()
10 {
11 if (instance == nullptr) {
12 std::lock_guard<std::mutex> lock(mtx); // 加锁
13 if (instance == nullptr) {
14 instance = new DoubleCheckSingleton(); // TODO 指令重排
15 }
16 }
17 return instance;
18 }
19#else
20 static DoubleCheckSingleton* getInstance()
21 {
22 if (shutdown_flag.load(std::memory_order_acquire)) {
23 return nullptr; // 程序正在关闭
24 }
25 // 原子操作 避免指令重排
26 auto* tmp = instance.load(std::memory_order_acquire);
27 if (tmp == nullptr) {
28 std::lock_guard<std::mutex> lock(mtx);
29 tmp = instance.load(std::memory_order_relaxed);
30 if (tmp == nullptr) {
31 tmp = new DoubleCheckSingleton();
32 instance.store(tmp, std::memory_order_release);
33 }
34 }
35 return tmp;
36 }
37#endif
38
39private:
40 DoubleCheckSingleton() = default; // 私有 构造函数，禁止外部实例化
41
42#if 1
43 static DoubleCheckSingleton* instance;
44#else
45 static std::atomic<DoubleCheckSingleton*> instance;
46 static std::atomic<bool> shutdown_flag;
47#endif
48
49 static std::mutex mtx;
50
51 // 嵌套类用于清理单例实例，但仍然存在程序退出时的竞态条件
52 // 如果程序退出时仍有线程在调用 getInstance()，可能出现：
53 // 线程A正在 GC::~GC() 中删除实例
54 // 线程B同时调用 getInstance() 并访问已删除的对象
55 class GC {
56 public:
57 ~GC()
58 {
59#if 1
60 std::lock_guard<std::mutex> lock(mtx);
61 if (DoubleCheckSingleton::instance) {
62 delete DoubleCheckSingleton::instance;
63 DoubleCheckSingleton::instance = NULL;
64 }
65#else
66 // 设置关闭标志，阻止新的getInstance调用
67 // 非原子操作，只能阻止新调用，不能停止已经获得指针的线程
68 shutdown_flag.store(true, std::memory_order_release);
69 std::lock_guard<std::mutex> lock(mtx);
70 auto* ptr = instance.load(std::memory_order_acquire);
71 if (ptr) {
72 delete ptr;
73 instance.store(nullptr, std::memory_order_release);
74 }
75#endif
76 }
77 };
78 static GC gc;
79};
80#if 1
81DoubleCheckSingleton* DoubleCheckSingleton::instance = nullptr;
82#else
83std::atomic<DoubleCheckSingleton*> DoubleCheckSingleton::instance{nullptr};
84std::atomic<bool> DoubleCheckSingleton::shutdown_flag {false};
85#endif
86std::mutex DoubleCheckSingleton::mtx;
87DoubleCheckSingleton::GC DoubleCheckSingleton::gc; 1// 编译器/CPU可能的执行顺序：
21. 分配内存：ptr = malloc(sizeof(DoubleCheckSingleton))
32. 构造对象：new(ptr) DoubleCheckSingleton()
43. 赋值指针：instance = ptr
5
6// 问题：编译器可能重排序为：
71. 分配内存：ptr = malloc(sizeof(DoubleCheckSingleton))
83. 赋值指针：instance = ptr // ← 提前赋值！
92. 构造对象：new(ptr) DoubleCheckSingleton() // ← 构造还没完成
10
11// 线程A执行重排序后的代码
12instance = ptr; // instance不再是nullptr
13
14// 此时线程B进入
15if (instance == nullptr) { // false，直接跳过锁
16}
17return instance; // 返回未完全构造的对象！
std::once_flag+智能指针
1class ModernLazySingleton {
2public:
3 ModernLazySingleton(const ModernLazySingleton&) = delete;
4 ModernLazySingleton& operator=(const ModernLazySingleton&) = delete;
5 ~ModernLazySingleton() = default;
6
7 static std::shared_ptr<ModernLazySingleton> getInstance()
8 {
9 std::call_once(onceFlag, createInstance);
10 return instance;
11 }
12
13private:
14 ModernLazySingleton() = default;
15
16 static void createInstance()
17 {
18 // instance = std::make_shared<ModernLazySingleton>(); // make_shared无法访问私有构造函数
19 instance = std::shared_ptr<ModernLazySingleton>(new ModernLazySingleton());
20 }
21
22 static std::shared_ptr<ModernLazySingleton> instance;
23 static std::once_flag onceFlag;
24 std::unique_ptr<SystemResourceHolder> resource;
25};
26std::shared_ptr<ModernLazySingleton> ModernLazySingleton::instance = nullptr;
27std::once_flag ModernLazySingleton::onceFlag;局部静态变量 Meyers’ Singleton
C++11 标准保证局部静态变量的初始化是线程安全的，且在第一次调用时才创建实例，实现了延迟初始化且简单。
1class LocalStaticSingleton {
2public:
3 LocalStaticSingleton(const LocalStaticSingleton&) = delete; // 删除 拷贝构造函数
4 LocalStaticSingleton& operator=(const LocalStaticSingleton&) = delete; // 删除 赋值运算符
5 ~LocalStaticSingleton() = default; // 默认 析构函数
6
7 static LocalStaticSingleton& getInstance()
8 {
9 static LocalStaticSingleton instance;
10 return instance;
11 }
12
13private:
14 LocalStaticSingleton() = default; // 私有 构造函数，禁止外部实例化
15};扩展
1template<typename T>
2class SingletonBase {
3public:
4 SingletonBase(const SingletonBase&) = delete;
5 SingletonBase& operator=(const SingletonBase&) = delete;
6
7 static T& getInstance()
8 {
9 static T instance;
10 return instance;
11 }
12
13protected:
14 SingletonBase() = default;
15 virtual ~SingletonBase() = default;
16};
17// 继承模板基类的单例
18class TemplateSingleton : public SingletonBase<TemplateSingleton> {
19 friend class SingletonBase<TemplateSingleton>; // 允许基类访问私有构造函数
20
21public:
22 ~TemplateSingleton()
23 {
24 std::cout << "TemplateSingleton 析构函数调用\n";
25 delete resource;
26 }
27
28private:
29 TemplateSingleton()
30 {
31 std::cout << "TemplateSingleton 构造函数调用\n";
32 resource = new SystemResourceHolder(7);
33 }
34 SystemResourceHolder* resource;
35};简述代理模式
代理模式为其他对象提供一种代理以控制对这个对象的访问。优点是可以增强目标对象的功能，降低代码耦合度，扩展性好。缺点是在客户端和目标对象之间增加代理对象会导致请求处理速度变慢，增加系统复杂度。 静态代理：在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就确定了。 动态代理：程序运行期间动态的生成，所以不存在代理类的字节码文件。代理类和委托类的关系是在程序运行时确定。
简述适配器模式
适配器模式将一个接口转换成客户希望的另一个接口，使接口不兼容的那些类可以一起工作。
1// 目标接口：客户端期望的接口
2class Target {
3public:
4 virtual ~Target() = default;
5 virtual void request() = 0;
6};
7
8// 被适配者：已存在但接口不匹配的类
9class Adaptee {
10public:
11 void specificRequest() {
12 std::cout << "特殊请求被处理" << std::endl;
13 }
14};
15
16// 适配器：将Adaptee的接口转换为Target接口
17class Adapter : public Target {
18private:
19 std::unique_ptr<Adaptee> adaptee;
20
21public:
22 Adapter() : adaptee(std::make_unique<Adaptee>()) {}
23
24 void request() override {
25 // 将Target的request()调用转换为Adaptee的specificRequest()调用
26 adaptee->specificRequest();
27 }
28};
29
30// 客户端代码
31void clientCode(Target* target) {
32 target->request();
33}简述模板模式
模板模式定义了一个操作中的算法的骨架，并将一些步骤延迟到子类，适用于抽取子类重复代码到公共父类。 可以封装固定不变的部分，扩展可变的部分。但每一个不同实现都需要一个子类维护，会增加类的数量。
1// 抽象基类：模板方法在这里定义（非虚，控制步骤顺序）
2class DataProcessor {
3public:
4 void process()
5 { // template method
6 load();
7 validate();
8 transform();
9 save();
10 }
11
12 virtual ~DataProcessor() = default;
13
14protected:
15 virtual void load() = 0; // 钩子/可变步骤
16 virtual void validate() {} // 可选覆盖（提供默认实现）
17 virtual void transform() = 0;
18 virtual void save() = 0;
19};
20
21// 具体实现 1
22class CsvProcessor : public DataProcessor {
23protected:
24 void load() override
25 {
26 std::cout << "[CSV] load data from CSV\n";
27 }
28 void validate() override
29 {
30 std::cout << "[CSV] validate CSV rows\n";
31 }
32 void transform() override
33 {
34 std::cout << "[CSV] transform CSV -> normalized records\n";
35 }
36 void save() override
37 {
38 std::cout << "[CSV] save to DB\n";
39 }
40};
41
42// 具体实现 2
43class JsonProcessor : public DataProcessor {
44protected:
45 void load() override
46 {
47 std::cout << "[JSON] load data from JSON\n";
48 }
49 void transform() override
50 {
51 std::cout << "[JSON] transform JSON -> normalized records\n";
52 }
53 void save() override
54 {
55 std::cout << "[JSON] save to DB\n";
56 }
57};
58
59int main()
60{
61 std::unique_ptr<DataProcessor> p1 = std::make_unique<CsvProcessor>();
62 std::unique_ptr<DataProcessor> p2 = std::make_unique<JsonProcessor>();
63
64 p1->process();
65 p2->process();
66 return 0;
67}策略模式
1// ---------- 传统接口方式 ----------
2struct CompressionStrategy {
3 virtual ~CompressionStrategy() = default;
4 virtual std::string compress(const std::string& data) = 0;
5};
6
7struct ZipStrategy : CompressionStrategy {
8 std::string compress(const std::string& data) override
9 {
10 return "ZIP[" + data + "]";
11 }
12};
13
14struct RarStrategy : CompressionStrategy {
15 std::string compress(const std::string& data) override
16 {
17 return "RAR[" + data + "]";
18 }
19};
20
21class Compressor {
22 std::unique_ptr<CompressionStrategy> strategy_;
23
24public:
25 explicit Compressor(std::unique_ptr<CompressionStrategy> s) : strategy_(std::move(s)) {}
26 void setStrategy(std::unique_ptr<CompressionStrategy> s) { strategy_ = std::move(s); }
27 std::string run(const std::string& data)
28 {
29 return strategy_->compress(data);
30 }
31};
32
33// ---------- 轻量函数式方式（更灵活，少类） ----------
34class FuncCompressor {
35 std::function<std::string(const std::string&)> func_;
36
37public:
38 explicit FuncCompressor(std::function<std::string(const std::string&)> f) : func_(std::move(f)) {}
39 void setFunc(std::function<std::string(const std::string&)> f) { func_ = std::move(f); }
40 std::string run(const std::string& data) { return func_(data); }
41};
42
43int main()
44{
45 Compressor c(std::make_unique<ZipStrategy>());
46 std::cout << c.run("payload") << "\n"; // ZIP[payload]
47 c.setStrategy(std::make_unique<RarStrategy>());
48 std::cout << c.run("payload") << "\n"; // RAR[payload]
49
50 // function style
51 FuncCompressor fc([](const std::string& s) { return "GZIP[" + s + "]"; });
52 std::cout << fc.run("payload") << "\n";
53 fc.setFunc([](const std::string& s) { return "LZ4[" + s + "]"; });
54 std::cout << fc.run("payload") << "\n";
55 return 0;
56}简述装饰器模式
装饰者模式可以动态地给对象添加一些额外的属性或行为，即需要修改原有的功能，但又不愿直接去修改原有的代码时，设计一个Decorator套在原有代码外面。
简述观察者模式
观察者模式表示的是一种对象与对象之间具有依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
1// 抽象观察者接口
2class Observer {
3public:
4 virtual ~Observer() = default; // 虚析构函数很重要！
5 virtual void update(const std::string& message) = 0;
6};
7
8// 抽象主题接口
9class Subject {
10public:
11 virtual ~Subject() = default;
12 virtual void attach(std::shared_ptr<Observer> observer) = 0;
13 virtual void detach(std::shared_ptr<Observer> observer) = 0;
14 virtual void notify() = 0;
15};
16
17// 具体观察者实现
18class ConcreteObserver : public Observer {
19private:
20 std::string name;
21
22public:
23 explicit ConcreteObserver(const std::string& n) :
24 name(n) {}
25
26 void update(const std::string& message) override
27 {
28 std::cout << "Observer [" << name << "] received: " << message << std::endl;
29 }
30
31 const std::string& getName() const { return name; }
32};
33
34// 具体主题实现
35class ConcreteSubject : public Subject {
36private:
37 std::vector<std::shared_ptr<Observer>> observers;
38 std::string state;
39
40public:
41 void attach(std::shared_ptr<Observer> observer) override
42 {
43 if (observer) { // 空指针检查
44 observers.push_back(observer);
45 }
46 }
47
48 void detach(std::shared_ptr<Observer> observer) override
49 {
50 observers.erase(
51 std::remove(observers.begin(), observers.end(), observer),
52 observers.end());
53 }
54
55 void notify() override
56 {
57 for (auto& obs : observers) {
58 if (obs) { // 确保观察者仍然有效
59 obs->update(state);
60 }
61 }
62 }
63
64 void setState(const std::string& newState)
65 {
66 state = newState;
67 notify(); // 状态改变时自动通知
68 }
69
70 const std::string& getState() const { return state; }
71};适配器模式
1// 目标接口：客户端期望的接口
2class Target {
3public:
4 virtual ~Target() = default;
5 virtual void request() = 0;
6};
7
8// 被适配者：已存在但接口不匹配的类
9class Adaptee {
10public:
11 void specificRequest() {
12 std::cout << "特殊请求被处理" << std::endl;
13 }
14};
15
16// 适配器：将Adaptee的接口转换为Target接口
17class Adapter : public Target {
18private:
19 std::unique_ptr<Adaptee> adaptee;
20
21public:
22 Adapter() : adaptee(std::make_unique<Adaptee>()) {}
23
24 void request() override {
25 // 将Target的request()调用转换为Adaptee的specificRequest()调用
26 adaptee->specificRequest();
27 }
28};
29
30// 客户端代码
31void clientCode(Target* target) {
32 target->request();
33}
34
35// 演示
36int main() {
37 std::cout << "=== 适配器模式演示 ===" << std::endl;
38
39 // 直接使用被适配者（接口不匹配）
40 Adaptee adaptee;
41 std::cout << "直接调用被适配者: ";
42 adaptee.specificRequest();
43
44 // 通过适配器使用（接口匹配）
45 std::unique_ptr<Target> adapter = std::make_unique<Adapter>();
46 std::cout << "通过适配器调用: ";
47 clientCode(adapter.get());
48
49 return 0;
50}