深入解析 C++ 设计模式：原理、实现与应用

一、引言

在 C++ 编程的广袤领域中，设计模式犹如闪耀的灯塔，为开发者指引着构建高效、可维护软件系统的方向。设计模式并非神秘莫测的代码魔法，实际上，我们在日常编程中或许早已与之打过交道。简单来说，设计模式常常借助多态这一强大特性，达成各式各样不同的操作方式。多态使得我们能够以统一的接口来应对不同类型的对象，为设计模式的实现筑牢了根基。接下来，让我们深入探索几种常见的设计模式。

二、策略模式

（一）模式概述

策略模式包含一组策略类以及一个决策者类。其中，这组策略类是一系列继承自同一个基类的类。策略类承担着实现丰富多样不同策略的职责，而决策者类则负责挑选合适的策略并予以执行。

（二）代码实现

// 策略基类，定义了一个纯虚函数 move，任何继承自此类的子类都必须实现该函数
// 此基类为所有具体的移动策略提供了统一的接口
class MovementStrategy {
public:// 纯虚函数，用于执行具体的移动操作virtual void move() = 0;// 虚析构函数，确保在通过基类指针删除派生类对象时，能正确调用派生类的析构函数virtual ~MovementStrategy() {}
};// 步行策略类，继承自 MovementStrategy 基类
// 该类实现了步行这种具体的移动策略
class WalkStrategy : public MovementStrategy {
public:// 重写基类的 move 函数，实现步行操作的具体逻辑void move() override {std::cout << "Character is walking." << std::endl;}
};// 跑步策略类，继承自 MovementStrategy 基类
// 该类实现了跑步这种具体的移动策略
class RunStrategy : public MovementStrategy {
public:// 重写基类的 move 函数，实现跑步操作的具体逻辑void move() override {std::cout << "Character is running." << std::endl;}
};// 决策者类，负责选择和执行具体的移动策略
class Character {
private:// 指向当前使用的移动策略对象的指针MovementStrategy* currentStrategy;
public:// 构造函数，初始化角色的移动策略Character(MovementStrategy* strategy) : currentStrategy(strategy) {}// 设置角色的移动策略void setStrategy(MovementStrategy* strategy) {currentStrategy = strategy;}// 调用当前移动策略的 move 函数，执行移动操作void move() {currentStrategy->move();}// 析构函数，释放当前使用的移动策略对象所占用的内存~Character() {delete currentStrategy;}
};

（三）工作原理与实现逻辑

策略基类：MovementStrategy作为策略基类，定义了纯虚函数move。这就为所有具体的移动策略（如步行、跑步等）制定了统一的接口规范。任何继承自该基类的子类都必须实现move函数，以提供具体的策略实现。同时，虚析构函数确保在通过基类指针删除派生类对象时，能够正确调用派生类的析构函数，避免内存泄漏。
具体策略类：WalkStrategy和RunStrategy分别继承自MovementStrategy基类。它们通过重写move函数，实现了各自独特的移动策略。WalkStrategy的move函数输出 “Character is walking.”，表示角色正在步行；RunStrategy的move函数输出 “Character is running.”，表示角色正在跑步。
决策者类：Character类作为决策者类，持有一个指向MovementStrategy对象的指针currentStrategy。在构造函数中，通过传入具体的策略对象来初始化currentStrategy。setStrategy函数用于动态更改角色当前使用的移动策略。move函数则调用currentStrategy所指向对象的move函数，从而执行当前选定的移动策略。在析构函数中，释放currentStrategy所指向的对象，以确保内存的正确管理。

三、代理模式

（一）模式概述

代理模式仅需一组类，但这组类包含两个具有不同功能的角色，即被代理者和代理者。

（二）代码实现

// 被代理类（远程数据库访问类）
// 该类负责实际从远程数据库获取数据
class RemoteDatabase {
public:// 获取远程数据库数据的函数std::string getData() {std::cout << "Accessing remote database..." << std::endl;return "Data from remote database";}
};// 代理类，用于代理对远程数据库的访问
// 引入缓存机制，减少对远程数据库的频繁访问
class DatabaseProxy {
private:// 指向被代理的远程数据库对象的指针RemoteDatabase* realDatabase;// 缓存从远程数据库获取的数据std::string cachedData;// 标记数据是否已缓存bool isCached;
public:// 构造函数，初始化被代理对象和缓存标记DatabaseProxy() : realDatabase(new RemoteDatabase), isCached(false) {}// 获取数据的函数，优先从缓存中获取，若缓存中没有则从远程数据库获取并缓存std::string getData() {if (isCached) {return cachedData;}cachedData = realDatabase->getData();isCached = true;return cachedData;}// 析构函数，释放被代理对象所占用的内存~DatabaseProxy() {delete realDatabase;}
};

（三）工作原理与实现逻辑

被代理类：RemoteDatabase类代表被代理的远程数据库访问对象。其getData函数用于从远程数据库获取数据，并在获取过程中输出 “Accessing remote database...”，表示正在访问远程数据库，最后返回从数据库获取到的数据。
代理类：DatabaseProxy类作为代理者，内部持有一个指向RemoteDatabase对象的指针realDatabase，以及用于缓存数据的cachedData和标记数据是否已缓存的isCached。在构造函数中，创建RemoteDatabase对象并初始化isCached为false。getData函数是代理模式的核心逻辑所在，首先检查isCached是否为true，若为true，则直接返回缓存中的数据cachedData，避免了再次访问远程数据库；若为false，则调用realDatabase的getData函数从远程数据库获取数据，将获取到的数据存入cachedData并将isCached设为true，最后返回数据。在析构函数中，释放realDatabase所指向的对象，确保内存的正确释放。

四、简单工厂模式

（一）模式概述

简单工厂模式下存在两组类，一组是产品类，另一组是工厂类。产品类包含各种各样不同的产品，每个产品能执行不同的任务。工厂类则依据提供的不同 “原材料”，生产出相应的产品。

（二）代码实现

// 产品基类，定义了一个纯虚函数 getResult，任何继承自此类的子类都必须实现该函数
// 此基类为所有具体的计算产品提供了统一的接口
class Operation {
public:// 纯虚函数，用于执行具体的计算操作并返回结果virtual int getResult(int num1, int num2) = 0;// 虚析构函数，确保在通过基类指针删除派生类对象时，能正确调用派生类的析构函数virtual ~Operation() {}
};// 加法运算类，继承自 Operation 基类
// 该类实现了加法计算这种具体的产品功能
class OperationAdd : public Operation {
public:// 重写基类的 getResult 函数，实现加法计算的具体逻辑int getResult(int num1, int num2) override {return num1 + num2;}
};// 减法运算类，继承自 Operation 基类
// 该类实现了减法计算这种具体的产品功能
class OperationSub : public Operation {
public:// 重写基类的 getResult 函数，实现减法计算的具体逻辑int getResult(int num1, int num2) override {return num1 - num2;}
};// 工厂类，负责根据传入的操作符生产相应的计算产品对象
class OperationFactory {
public:// 静态工厂方法，根据传入的操作符创建对应的计算产品对象static Operation* createOperation(const std::string& operate) {if (operate == "+") {return new OperationAdd;} else if (operate == "-") {return new OperationSub;}return nullptr;}
};

（三）工作原理与实现逻辑

产品基类：Operation作为产品基类，定义了纯虚函数getResult，用于执行具体的计算操作并返回结果。这为所有具体的计算产品（如加法、减法等）提供了统一的接口。任何继承自该基类的子类都必须实现getResult函数，以实现各自特定的计算功能。同时，虚析构函数确保在通过基类指针删除派生类对象时，能够正确调用派生类的析构函数，防止内存泄漏。
具体产品类：OperationAdd和OperationSub分别继承自Operation基类。它们通过重写getResult函数，实现了各自的计算逻辑。OperationAdd的getResult函数将传入的两个数相加并返回结果，OperationSub的getResult函数则将两个数相减并返回结果。
工厂类：OperationFactory类作为工厂类，提供了一个静态的createOperation方法。该方法接收一个表示操作符的字符串operate作为参数，根据operate的值判断需要创建的产品类型。如果operate为 “+”，则创建一个OperationAdd对象并返回；如果operate为 “-”，则创建一个OperationSub对象并返回；若传入的操作符不匹配任何已知的操作，则返回nullptr。这种方式使得产品的创建逻辑集中在工厂类中，方便管理和维护。

（四）优缺点

优点：逻辑简单直白，易于理解和实现。对于简单的对象创建场景，使用简单工厂模式可以快速搭建起系统的对象创建框架。
缺点：违反 “开闭原则”。当需要添加新的产品类（如乘法、除法运算类）时，必须修改工厂类的createOperation方法，添加新的条件判断逻辑。这不仅增加了修改现有代码的风险，还可能导致其他依赖该工厂类的代码出现问题，不利于系统的维护和拓展。

五、工厂方法模式

（一）模式概述

工厂方法模式同样包含一组产品类和一组工厂类。该模式旨在解决简单工厂模式违反开闭原则的问题，它将每个产品都对应到一个独立的工厂类去生产，即每个工厂只能生产一种产品。

（二）代码实现

// 产品基类，定义了一个纯虚函数 getResult，任何继承自此类的子类都必须实现该函数
// 此基类为所有具体的计算产品提供了统一的接口
class Operation {
public:// 纯虚函数，用于执行具体的计算操作并返回结果virtual int getResult(int num1, int num2) = 0;// 虚析构函数，确保在通过基类指针删除派生类对象时，能正确调用派生类的析构函数virtual ~Operation() {}
};// 加法运算类，继承自 Operation 基类
// 该类实现了加法计算这种具体的产品功能
class OperationAdd : public Operation {
public:// 重写基类的 getResult 函数，实现加法计算的具体逻辑int getResult(int num1, int num2) override {return num1 + num2;}
};// 减法运算类，继承自 Operation 基类
// 该类实现了减法计算这种具体的产品功能
class OperationSub : public Operation {
public:// 重写基类的 getResult 函数，实现减法计算的具体逻辑int getResult(int num1, int num2) override {return num1 - num2;}
};// 加法工厂类，专门用于生产加法运算对象
class AddFactory {
public:// 静态工厂方法，创建并返回一个加法运算对象static Operation* createOperation() {return new OperationAdd;}
};// 减法工厂类，专门用于生产减法运算对象
class SubFactory {
public:// 静态工厂方法，创建并返回一个减法运算对象static Operation* createOperation() {return new OperationSub;}
};

（三）工作原理与实现逻辑

产品基类与具体产品类：这部分与简单工厂模式类似，Operation作为产品基类定义了统一的接口getResult，OperationAdd和OperationSub等具体产品类继承自Operation基类，并实现了各自的计算逻辑。
工厂类：在工厂方法模式中，每个产品都有对应的工厂类。AddFactory专门用于创建OperationAdd对象，其createOperation方法返回一个新的OperationAdd实例；SubFactory专门用于创建OperationSub对象，其createOperation方法返回一个新的OperationSub实例。当需要添加新的产品类（如乘法运算类OperationMul）时，只需创建对应的工厂类（如MulFactory），并在其中实现创建OperationMul对象的逻辑，而无需修改现有的工厂类代码，从而遵循了开闭原则。

（四）优缺点

缺点：前期代码量大，因为每一个产品都需要一个独立工厂去生产，这无疑增加了代码的编写量和维护成本。例如，若有多种不同类型的计算产品，就需要创建同样数量的工厂类。
优点：遵循了开闭原则，易于维护拓展。当系统需要添加新的产品时，只需创建新的产品类和对应的工厂类，而不会影响到现有的代码。同时，独立工厂生产能够方便地进行定制化，比如可以在工厂类中添加特定的初始化逻辑或资源分配逻辑，以满足不同产品的特殊需求。

六、抽象工厂模式

（一）模式概述

抽象工厂模式包含多组产品类和一组工厂类。工厂类能够生产多个产品，并且不同的工厂生产的产品品牌不同。

（二）代码实现

// 空调抽象类，定义了一个纯虚函数 showInfo，任何继承自此类的子类都必须实现该函数
// 此基类为所有具体品牌的空调产品提供了统一的接口
class AirConditioner {
public:// 纯虚函数，用于展示空调的信息virtual void showInfo() = 0;// 虚析构函数，确保在通过基类指针删除派生类对象时，能正确调用派生类的析构函数virtual ~AirConditioner() {}
};// 美的空调类，继承自 AirConditioner 基类
// 该类实现了美的品牌空调的具体信息展示功能
class MideaAirConditioner : public AirConditioner {
public:// 重写基类的 showInfo 函数，展示美的空调的信息void showInfo() override {std::cout << "This is Midea air conditioner." << std::endl;}
};// 格力空调类，继承自 AirConditioner 基类
// 该类实现了格力品牌空调的具体信息展示功能
class GreeAirConditioner : public AirConditioner {
public:// 重写基类的 showInfo 函数，展示格力空调的信息void showInfo() override {std::cout << "This is Gree air conditioner." << std::endl;}
};// 电冰箱抽象类，定义了一个纯虚函数 showInfo，任何继承自此类的子类都必须实现该函数
// 此基类为所有具体品牌的电冰箱产品提供了统一的接口
class Refrigerator {
public:// 纯虚函数，用于展示电冰箱的信息virtual void showInfo() = 0;// 虚析构函数，确保在通过基类指针删除派生类对象时，能正确调用派生类的析构函数virtual ~Refrigerator() {}
};// 美的电冰箱类，继承自 Refrigerator 基类
// 该类实现了美的品牌电冰箱的具体信息展示功能
class MideaRefrigerator : public Refrigerator {
public:// 重写基类的 showInfo 函数，展示美的电冰箱的信息void showInfo() override {std::cout << "This is Midea refrigerator." << std::endl;}
};// 格力电冰箱类，继承自 Refrigerator 基类
// 该类实现了格力品牌电冰箱的具体信息展示功能
class GreeRefrigerator : public Refrigerator {
public:// 重写基类的 showInfo 函数，展示格力电冰箱的信息void showInfo() override {std::cout << "This is Gree refrigerator." << std::endl;}