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++中使用。学习和理解这些设计模式可以帮助你更好地设计出高质量的软件系统。

相关推荐
_哆啦A梦18 小时前
Vibe Coding 全栈专业名词清单｜设计模式·基础篇（创建型+结构型核心名词）
前端·设计模式·vibecoding
端平入洛2 天前
delete又未完全delete
c++
端平入洛3 天前
auto有时不auto
c++
哇哈哈20214 天前
信号量和信号
linux·c++
多恩Stone4 天前
【C++入门扫盲1】C++ 与 Python：类型、编译器/解释器与 CPU 的关系
开发语言·c++·人工智能·python·算法·3d·aigc
蜡笔小马4 天前
21.Boost.Geometry disjoint、distance、envelope、equals、expand和for_each算法接口详解
c++·算法·boost
超级大福宝4 天前
N皇后问题：经典回溯算法的一些分析
数据结构·c++·算法·leetcode
weiabc4 天前
printf(“%lf“, ys) 和 cout ＜＜ ys 输出的浮点数格式存在细微差异
数据结构·c++·算法
问好眼4 天前
《算法竞赛进阶指南》0x01 位运算-3.64位整数乘法
c++·算法·位运算·信息学奥赛
yyjtx4 天前
DHU上机打卡D31
开发语言·c++·算法
热门推荐
01GitHub 镜像站点02【OpenClaw 本地实战 Ep.3】突破瓶颈：强制修改 openclaw.json 解锁 32k 上下文记忆03OpenClaw 使用和管理 MCP 完全指南04OpenClaw + 飞书（Feishu）环境搭建指南05OpenClaw优化飞书API 额度已耗尽问题06Clawdbot部署教程：解决‘gateway token missing’授权问题的完整步骤07Window 10部署openclaw报错node.exe : npm error code 12808Claude Code + GLM4.7 避坑指南：解决 Unable to connect to Anthropic services09OpenClaw 接入阿里云百炼 Coding Plan 指南10OpenClaw大龙虾机器人完整安装教程