C++：23种设计模式

最新推荐文章于 2025-04-01 09:47:31 发布

月咏倾江华

最新推荐文章于 2025-04-01 09:47:31 发布

阅读量5.8k

点赞数 36

文章标签：设计模式

本文链接：https://blog.csdn.net/weixin_53442127/article/details/140918150

版权

本文将介绍编程中的23种设计模式，用C++语言编写。

二、正文

2.工厂方法模式（Factory Method）

3.抽象工厂模式（Abstract Factory）

13.责任链模式（Chain of Responsibility）

14.命令模式（Command）

15.解释器模式（Interpreter）

22.模板方法模式（Template Method）

23.访问者模式（Visitor）

三、总结

前言

设计模式是软件设计中常用的解决方案，分为三大类：创建型模式、结构型模式和行为型模式。以下是23种设计模式的简要介绍和C++代码示例。

正文

创建型模式

创建型模式关注对象的创建过程，旨在通过隐藏创建逻辑来提高代码的灵活性和可维护性。单例模式确保一个类只有一个实例，适用于需要全局访问的资源，如配置文件或数据库连接池。工厂方法模式和抽象工厂模式通过定义创建对象的接口，允许子类或具体工厂决定实例化的具体类，适用于需要灵活创建对象的场景。建造者模式将复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。原型模式通过复制现有实例来创建新对象，适用于需要大量相似对象的场景。

1.单例模式（Singleton）

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

class Singleton {
public:
    static Singleton& getInstance() {
        static Singleton instance;
        return instance;
    }

private:
    Singleton() {}

    Singleton(const Singleton&) = delete;

    Singleton& operator=(const Singleton&) = delete;
};

2.工厂方法模式（Factory Method）

定义一个创建对象的接口，但由子类决定实例化哪一个类。

class Product {
public:
    virtual void use() = 0;
};

class ConcreteProduct : public Product {
public:
    void use() override {
    // Implementation
    }
};

class Creator {
public:
    virtual Product* factoryMethod() = 0;
};

class ConcreteCreator : public Creator {
public:
    Product* factoryMethod() override {
        return new ConcreteProduct();
    }
};

3.抽象工厂模式（Abstract Factory）

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

class AbstractProductA {
public:
    virtual void use() = 0;
};

class AbstractProductB {
public:
    virtual void use() = 0;
};

class ConcreteProductA1 : public AbstractProductA {
public:
    void use() override {
    // Implementation
    }
};

class ConcreteProductB1 : public AbstractProductB {
public:
    void use() override {
    // Implementation
    }
};

class AbstractFactory {
public:
    virtual AbstractProductA* createProductA() = 0;
    virtual AbstractProductB* createProductB() = 0;
};

class ConcreteFactory1 : public AbstractFactory {
public:
    AbstractProductA* createProductA() override {
        return new ConcreteProductA1();
    }

    AbstractProductB* createProductB() override {
        return new ConcreteProductB1();
    }
};

4.建造者模式（Builder）

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

class Product {
public:
    void setPartA(const std::string& part) {     
        partA = part; 
    }

    void setPartB(const std::string& part) { 
        partB = part; 
    }
private:
    std::string partA;
    std::string partB;
};

class Builder {
public:
    virtual void buildPartA() = 0;
    virtual void buildPartB() = 0;
    virtual Product* getResult() = 0;
};

class ConcreteBuilder : public Builder {
public:
    ConcreteBuilder() { 
        product = new Product(); 
    }

    void buildPartA() override { 
        product->setPartA("PartA"); 
    }

    void buildPartB() override { 
        product->setPartB("PartB"); 
    }

    Product* getResult() override { 
        return product; 
    }
private:
    Product* product;
};

class Director {
public:
    void setBuilder(Builder* b) { 
        builder = b; 
    }

    void construct() {
        builder->buildPartA();
        builder->buildPartB();
    }
private:
    Builder* builder;
};

5.原型模式（Prototype）

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

class Prototype {
public:
    virtual Prototype* clone() = 0;
};

class ConcretePrototype : public Prototype {
public:
    ConcretePrototype(int value) : value(value) {}

    Prototype* clone() override {
        return new ConcretePrototype(*this);
    }
private:
    int value;
};

结构型模式

结构型模式关注类和对象的组合，旨在通过继承和组合来实现更大的灵活性和可扩展性。适配器模式将一个类的接口转换成客户希望的另一个接口，使得原本由于接口不兼容而不能一起工作的类可以一起工作。桥接模式将抽象部分与其实现部分分离，使它们可以独立变化。组合模式将对象组合成树形结构，以表示“部分-整体”的层次结构，适用于需要处理树形结构的场景。装饰模式动态地给对象添加职责，比生成子类更灵活。外观模式为子系统提供一个一致的接口，简化其使用。享元模式通过共享技术有效地支持大量细粒度对象，适用于需要大量相似对象的场景。代理模式为其他对象提供一种代理以控制对这个对象的访问，适用于需要控制访问的场景。