C++ 设计模式

一条闲鱼。2024-06-18 12:03

在C++中，设计模式（Design Patterns）是用于解决在软件设计中经常遇到的一些通用问题的最佳实践。这些设计模式是在多年的软件开发过程中积累下来的经验和智慧的结晶。它们可以帮助开发者设计出更加灵活、可维护、可扩展的软件系统。以下是一些在C++中常用的设计模式，详细见22种设计模式。

1、单例模式（Singleton Pattern）：

确保一个类只有一个实例，并提供一个全局访问点。

cpp 复制代码 
class Singleton {  
private:  
    static Singleton* instance;  
    Singleton() {}  
    Singleton(const Singleton&) = delete;  
    Singleton& operator=(const Singleton&) = delete;  
public:  
    static Singleton* getInstance() {  
        if (!instance) {  
            instance = new Singleton();  
        }  
        return instance;  
    }  
    // ... 其他成员函数 ...  
};  
  
Singleton* Singleton::instance = nullptr;

注意：上述这种写法并非线程安全的，为了保证单例的线程安全，有以下几种方式：

饿汉式（立即初始化）：

cpp 复制代码 
class Singleton {  
public:  
    static Singleton& getInstance() {  
        return instance;  
    }  
  
    Singleton(const Singleton&) = delete;  
    Singleton& operator=(const Singleton&) = delete;  
  
private:  
    Singleton() {}  
    static Singleton instance; // 静态局部变量，在类加载时初始化  
};  
  
Singleton Singleton::instance; // 静态成员变量在类外初始化

懒汉式（双重检查锁）：

cpp 复制代码 
class Singleton {  
public:  
    static Singleton& getInstance() {  
        if (instance == nullptr) { // 第一次检查  
            std::lock_guard<std::mutex> lock(mutex); // 加锁  
            if (instance == nullptr) { // 第二次检查  
                instance = new Singleton();  
            }  
        }  
        return *instance;  
    }  
  
    Singleton(const Singleton&) = delete;  
    Singleton& operator=(const Singleton&) = delete;  
  
private:  
    Singleton() {}  
    static Singleton* instance;  
    static std::mutex mutex; // 用于同步的互斥量  
};  
  
Singleton* Singleton::instance = nullptr;  
std::mutex Singleton::mutex;

静态内部类（C++11以后推荐）：

cpp 复制代码 
class Singleton {  
public:  
    static Singleton& getInstance() {  
        return SingletonHolder::instance;  
    }  
  
    Singleton(const Singleton&) = delete;  
    Singleton& operator=(const Singleton&) = delete;  
  
private:  
    Singleton() {}  
  
    struct SingletonHolder {  
        static Singleton instance;  
    };  
  
    static SingletonHolder holder; // 静态成员变量，保证在第一次调用getInstance时初始化  
};  
  
Singleton::SingletonHolder Singleton::holder; // 静态成员变量在类外初始化  
Singleton Singleton::SingletonHolder::instance; // 静态局部对象，在holder初始化时初始化

2、工厂模式（Factory Pattern）：

用于封装对象的创建过程，隐藏创建细节，使得代码更加灵活和可扩展。工厂模式主要分三种：简单工厂模式、工厂方法模式和抽象工厂模式。

简单工厂模式：

cpp 复制代码 
// 产品接口  
class Product {  
public:  
    virtual ~Product() {}  
    virtual void use() = 0;  
};  
  
// 产品实现  
class ProductA : public Product {  
public:  
    void use() override {  
        std::cout << "Using ProductA" << std::endl;  
    }  
};  
  
class ProductB : public Product {  
public:  
    void use() override {  
        std::cout << "Using ProductB" << std::endl;  
    }  
};  
  
// 简单工厂类  
class SimpleFactory {  
public:  
    static Product* createProduct(const std::string& type) {  
        if (type == "A") {  
            return new ProductA();  
        } else if (type == "B") {  
            return new ProductB();  
        }  
        return nullptr;  
    }  
};  
  
// 客户端代码  
int main() {  
    Product* productA = SimpleFactory::createProduct("A");  
    if (productA) {  
        productA->use();  
        delete productA;  
    }  
  
    Product* productB = SimpleFactory::createProduct("B");  
    if (productB) {  
        productB->use();  
        delete productB;  
    }  
  
    return 0;  
}

工厂方法模式：

cpp 复制代码 
// 产品接口  
class Product {  
public:  
    virtual ~Product() {}  
    virtual void use() = 0;  
};  
  
// 产品实现  
class ProductA : public Product {  
public:  
    void use() override {  
        std::cout << "Using ProductA" << std::endl;  
    }  
};  
  
class ProductB : public Product {  
public:  
    void use() override {  
        std::cout << "Using ProductB" << std::endl;  
    }  
};  
  
// 工厂接口  
class Creator {  
public:  
    virtual ~Creator() {}  
    virtual Product* createProduct() = 0;  
};  
  
// 工厂实现  
class CreatorA : public Creator {  
public:  
    Product* createProduct() override {  
        return new ProductA();  
    }  
};  
  
class CreatorB : public Creator {  
public:  
    Product* createProduct() override {  
        return new ProductB();  
    }  
};  
  
// 客户端代码  
int main() {  
    Creator* creatorA = new CreatorA();  
    Product* productA = creatorA->createProduct();  
    productA->use();  
    delete productA;  
    delete creatorA;  
  
    Creator* creatorB = new CreatorB();  
    Product* productB = creatorB->createProduct();  
    productB->use();  
    delete productB;  
    delete creatorB;  
  
    return 0;  
}

抽象工厂模式：

cpp 复制代码 
// 产品接口  
class ProductA {  
public:  
    virtual ~ProductA() {}  
    virtual void use() = 0;  
};  
  
class ProductB {  
public:  
    virtual ~ProductB() {}  
    virtual void use() = 0;  
};  
  
// 产品实现  
class ProductA1 : public ProductA {  
public:  
    void use() override {  
        std::cout << "Using ProductA1" << std::endl;  
    }  
};  
  
class ProductB1 : public ProductB {  
public:  
    void use() override {  
        std::cout << "Using ProductB1" << std::endl;  
    }  
};  
  
// 抽象工厂接口  
class AbstractFactory {  
public:  
    virtual ~AbstractFactory() {}  
    virtual ProductA* createProductA() = 0;  
    virtual ProductB* createProductB() = 0;  
};  
  
// 工厂实现  
class Factory1 : public AbstractFactory {  
public:  
    ProductA* createProductA() override {  
        return new ProductA1();  
    }  
  
    ProductB* createProductB() override {  
        return new ProductB1();  
    }  
};  
  
// 客户端代码  
int main() {  
    AbstractFactory* factory = new Factory1();  
    ProductA* productA = factory->createProductA();  
    ProductB* productB = factory->createProductB();  
    productA->use();  
    productB->use();

3、观察者模式（Observer Pattern）：

定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。当主题对象状态发生改变时，它的所有依赖者（观察者）都会自动收到通知并更新。

cpp 复制代码 
class Subject {  
    // ...  
    std::list<Observer*> observers;  
    void notify() {  
        for (auto observer : observers) {  
            observer->update();  
        }  
    }  
    // ...  
};  
  
class Observer {  
public:  
    virtual void update() = 0;  
    // ...  
};

4、建造者模式（Builder Pattern）：

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

cpp 复制代码 
class Builder {  
public:  
    virtual void buildPartA() = 0;  
    virtual void buildPartB() = 0;  
    // ...  
    virtual Product* getResult() = 0;  
};  
  
class ConcreteBuilder : public Builder {  
    Product* product;  
    // 实现构建过程  
    // ...  
};  
  
class Director {  
public:  
    void construct(Builder* builder) {  
        builder->buildPartA();  
        builder->buildPartB();  
        // ...  
    }  
};

5、原型模式（Prototype Pattern）：

用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

cpp 复制代码 
class Prototype {  
public:  
    virtual Prototype* clone() = 0;  
    // ...  
};  
  
class ConcretePrototype : public Prototype {  
public:  
    ConcretePrototype* clone() override {  
        return new ConcretePrototype(*this); // 拷贝构造函数实现克隆  
    }  
    // ...  
};

6、适配器模式（Adapter Pattern）：

将一个类的接口转换成客户端所期望的另一种接口，从而使得原本由于接口不兼容而无法一起工作的类能够一起工作。
7、迭代器模式（Iterator Pattern）：

提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。
8、组合模式（Composite Pattern）：

将对象组合成树形结构以表示"部分-整体"的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。
9、模板方法模式（Template Method Pattern）：

定义一个操作中的算法的框架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重新定义该算法的某些特定步骤。
10、策略模式（Strategy Pattern）：

定义了一系列的算法，并将每一个算法封装起来，使它们可以互相替换。策略模式使得算法可以独立于使用它的客户端变化。

以上只是设计模式中的一部分，还有其他许多设计模式可以在C++中使用。学习和理解这些设计模式可以帮助你更好地设计出高质量的软件系统。

相关推荐
醉颜凉1 小时前
【NOIP提高组】潜伏者
java·c语言·开发语言·c++·算法
hunandede1 小时前
FFmpeg 4.3 音视频-多路H265监控录放C++开发十三.2：avpacket中包含多个 NALU如何解析头部分析
c++·ffmpeg·音视频
爱学习的大牛1231 小时前
通过vmware虚拟机安装和调试编译好的 ReactOS
c++·windows内核
tumu_C3 小时前
C++模板特化实战：在使用开源库boost::geometry::index::rtree时，用特化来让其支持自己的数据类型
c++·开源
杜若南星3 小时前
保研考研机试攻略（满分篇）：第二章——满分之路上（1）
数据结构·c++·经验分享·笔记·考研·算法·贪心算法
Neophyte06083 小时前
C++算法练习-day40——617.合并二叉树
开发语言·c++·算法
云空3 小时前
《InsCode AI IDE：编程新时代的引领者》
java·javascript·c++·ide·人工智能·python·php
写bug的小屁孩3 小时前
websocket初始化
服务器·开发语言·网络·c++·websocket·网络协议·qt creator
matrixlzp3 小时前
Java 责任链模式 减少 if else 实战案例
java·设计模式
湖南罗泽南4 小时前
Windows C++ TCP/IP 两台电脑上互相传输字符串数据
c++·windows·tcp/ip
热门推荐
01玄机平台应急响应—webshell查杀02Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04【TC3xx芯片】TC3xx芯片电源管理系统PMS详解05文件或文件夹名称中有空格如何批量去除06组基轨迹建模 GBTM的介绍与实现（Stata 或 R）07智能车联网安全发展形势、挑战08优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间09基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测10液体神经网络：LNN是个啥概念？