C++23种设计模式&软件设计模型

以下是C++中常用的23种设计模式：

1. 创建型模式（Creational Patterns）：

   • 工厂方法（Factory Method）
   • 抽象工厂（Abstract Factory）
   • 单例（Singleton）
   • 原型（Prototype）
   • 建造者（Builder）

2. 结构型模式（Structural Patterns）：

   • 适配器（Adapter）
   • 桥接（Bridge）
   • 组合（Composite）
   • 装饰器（Decorator）
   • 外观（Facade）
   • 享元（Flyweight）
   • 代理（Proxy）

3. 行为型模式（Behavioral Patterns）：

   • 观察者（Observer）
   • 迭代器（Iterator）
   • 策略（Strategy）
   • 命令（Command）
   • 模板方法（Template Method）
   • 职责链（Chain of Responsibility）
   • 备忘录（Memento）
   • 状态（State）
   • 访问者 （Visitor）

4. 其他类型的模式： 在某些分类中，还会提到一些其他类型的模式，例如： ————并发性模式：如生产者-消费者、读写锁等。 ————架构模式：如MVC、MVVM等。

软件设计模型：瀑布模型 原型模型 演化模型 增量模型 V模型 喷泉模型

这篇文章就简要的介绍几个

1.简单工厂方法(创建型模式)：用于将对象的实例化过程封装在一个独立的工厂类中。通过使用工厂方法，可以隐藏具体对象的创建细节，使得客户端代码与具体对象之间解耦

uml类图（代码逻辑根据uml类图来实现）：

代码如下：

#include 

// 抽象产品接口
class Product 
{
public:
    virtual void operation() = 0;//纯虚函数 继承的是虚函数指针和虚函数表 要注意
};

// 具体产品A
class ConcreteProductA : public Product {
public:
    void operation() override 
    {
        std::cout << "ConcreteProductA operation" << std::endl;
    }
};

// 具体产品B
class ConcreteProductB : public Product {
public:
    void operation() override//检测子类虚函数是否成功覆盖父类虚函数
    {
        std::cout << "ConcreteProductB operation" << std::endl;
    }
};

// 抽象工厂接口
class Factory {
public:
    virtual Product* createProduct() = 0;
};

// 具体工厂A
class ConcreteFactoryA : public Factory {
public:
    Product* createProduct() override {
        return new ConcreteProductA();
    }
};

// 具体工厂B
class ConcreteFactoryB : public Factory {
public:
    Product* createProduct() override {
        return new ConcreteProductB();
    }
};
int main() 
{
    Factory* factoryA = new ConcreteFactoryA();
    Product* productA = factoryA->createProduct();
    productA->operation(); // Output: ConcreteProductA operation

    Factory* factoryB = new ConcreteFactoryB();
    Product* productB = factoryB->createProduct();
    productB->operation(); // Output: ConcreteProductB operation

    delete factoryA;
    delete productA;

    delete factoryB;
    delete productB;

    return 0;
}
//results:
ConcreteProductA operation
ConcreteProductB operation

（结构型模式）适配器模式：配器模式是一种结构设计模式，它用于将一个类的接口转换成客户端所期望的另一个接口。

适配器模式主要涉及以下几个角色：

1. 目标接口（Target Interface）：客户端所期望的接口，定义了客户端代码可以调用的方法。

2. 被适配者（Adaptee）：需要被适配的已有类，拥有不兼容于目标接口的方法。

3. 适配器（Adapter）：连接目标接口和被适配者的中间类，实现了目标接口，并持有被适配者对象，以便将请求转发给被适配者。

在使用适配器模式时，可以分为两种类型：

• 类适配器：使用多重继承方式，在适配器类中同时继承目标接口和被适配者类。通过重写目标接口方法并调用被适配者类的方法来完成转换。
• 对象适配器：使用组合关系，在适配器类中持有一个被适配者对象，并实现目标接口。通过调用被适配者对象的方法来完成转换。

适配器模式常用于以下场景：

• 当需要使用一个已经存在的类，但其接口与其他代码不兼容时，可以通过适配器模式将其接口转换成符合需求的形式。
• 在系统设计中，为了解耦和增强可维护性，引入新的功能或服务时，可以使用适配器模式将其与现有的代码进行整合。

总而言之，适配器模式允许不兼容的类能够一起工作，通过封装和转换来满足客户端的需求。它提供了一种灵活且可扩展的方式来集成现有代码和第三方组件。

uml类图：

#include
using namespace std;
// 目标接口（Target interface）
class Target {
public:
    virtual void request() = 0;
};

// 被适配者（Adaptee）
class Adaptee {
public:
    void specificRequest() {
        // 具体操作
        std::cout << "Adaptee's specific request." << std::endl;
    }
};

// 类适配器（Class Adapter）
class ClassAdapter : public Target, private Adaptee {
public:
    void request() override {
        specificRequest();  // 调用被适配者的方法
    }
};

// 对象适配器（Object Adapter）
class ObjectAdapter : public Target {
private:
    Adaptee* adaptee;

public:
    ObjectAdapter(Adaptee* adaptee) : adaptee(adaptee) {}

    void request() override {
        adaptee->specificRequest();  // 调用被适配者的方法
    }
};

int main() {
    // 使用类适配器
    Target* target1 = new ClassAdapter();
    target1->request();

    // 使用对象适配器
    Adaptee* adaptee = new Adaptee();
    Target* target2 = new ObjectAdapter(adaptee);
    target2->request();

    delete target1;
    delete target2;

    return 0;
}
//结果 Adaptee's specific request

（创建型模式 面试重点）单例模式是一种创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点以获取该实例。有以下五个特征：

1. 单一实例：单例类只能存在一个实例对象。

2. 全局访问：通过静态方法可以全局访问该单例实例。

3. 延迟初始化：在第一次调用获取实例的方法时才进行对象的初始化。

4. 线程安全：合理考虑多线程环境下的并发访问问题，确保单例对象在多线程情况下仍然是唯一的。

5. 私有构造函数：禁止外部直接使用new操作符来创建对象，保证单例类的控制权。

单例模式重点：

1.私有化构造函数

2.设置私有静态成员变量

3. 删除拷贝构造函数和赋值运算符重载，以禁止复制实例

代码实例：

#include
using namespace std;
class Singleton {
private:
    static Singleton* instance;

    // 私有构造函数，防止外部直接实例化
    Singleton() {
        // 初始化操作
    }

public:
    // 获取单例实例的静态方法
    static Singleton* getInstance() {
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }

    // 删除拷贝构造函数和赋值运算符重载，以禁止复制实例
    Singleton(const Singleton&) = delete;
    void operator=(const Singleton&) = delete;

    // 其他方法
    void doSomething() {
        cout << "Singleton: Doing something..." << endl;
    }
};

Singleton* Singleton::instance = nullptr;//避免野指针的产生

总结：

单例模式是只能拥有一个对象并且要将所有能够构造对象的函数设置为私有或者剔除

简单工厂模式就是对纯虚函数 虚函数 虚函数指针 虚函数表的理解和使用 并且对简单工厂模式要有一定的了解

3.适配器模式就是将原来开发的接口对于用户不符 然后转换成用户 所期待的接口 这样可以避免因改动整个代码而产生时间损失 精力损失 财富损失 而改变一个接口可以很好的提高企业开发的效率

本期的常见的设计模式就介绍到这里了 在这里小编有一个课程想分享给大家

https://xxetb.xetslk.com/s/2PjJ3T