【C++】设计模式：建造者、原型、单例

★,°:.☆(￣▽￣)/$:.°★

这篇文章主要介绍设计模式：建造者、原型、单例。

学其所用，用其所学。——梁启超

欢迎来到我的博客，一起学习，共同进步。

喜欢的朋友可以关注一下，下次更新不迷路

文章目录

• • :smirk:1. 建造者模式
  • :blush:2. 原型模式
  • :satisfied:3. 单例模式

    1. 建造者模式

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

    建造者模式的结构包含以下几个角色：

    • 抽象建造者（AbstractBuilder）：创建一个Product对象的各个部件指定的抽象接口；
    • 具体建造者（ConcreteBuilder）：实现AbstractBuilder的接口，实现各个部件的具体构造方法和装配方法，并返回创建结果。
    • 产品（Product）：具体的产品对象
    • 指挥者（Director）： 构建一个使用Builder接口的对象，安排复杂对象的构建过程，客户端一般只需要与Director交互，指定建造者类型，然后通过构造函数或者setter方法将具体建造者对象传入Director。它主要作用是：隔离客户与对象的生产过程，并负责控制产品对象的生产过程

      #include #include // 产品类class Product {public:    void setPartA(const std::string& partA) {        partA_ = partA;    }    void setPartB(const std::string& partB) {        partB_ = partB;    }    void setPartC(const std::string& partC) {        partC_ = partC;    }    void show() {        std::cout public:    virtual void buildPartA() = 0;    virtual void buildPartB() = 0;    virtual void buildPartC() = 0;    virtual Product* getProduct() = 0;};// 具体建造者类 Aclass ConcreteBuilderA : public Builder {public:    void buildPartA() override {        product_-setPartA("PartA of Product A");    }    void buildPartB() override {        product_-setPartB("PartB of Product A");    }    void buildPartC() override {        product_-setPartC("PartC of Product A");    }    Product* getProduct() override {        return product_;    }private:    Product* product_ = new Product();};// 指挥者类class Director {public:    void construct(Builder* builder) {        builder-buildPartA();        builder-buildPartB();        builder-buildPartC();    }};int main() {    Director director;    ConcreteBuilderA builderA;    director.construct(&builderA);    Product* productA = builderA.getProduct();    productA-show();    delete productA;    return 0;}

      适用环境：

      • 需要生成的产品对象有复杂的内部结构（通常包含多个成员变量）；
      • 产品对象内部属性有一定的生成顺序；
      • 同一个创建流程适用于多种不同的产品。

        2. 原型模式

        原型模式：使用原型实例指定待创建对象的类型，并且通过复制这个原型来创建新的对象。

        原型式的结构包含以下几个角色：

        • 抽象原型类（AbstractPrototype）：声明克隆clone自身的接口
        • 具体原型类（ConcretePrototype）：实现clone接口
        • 客户端（Client）：客户端中声明一个抽象原型类，根据客户需求clone具体原型类对象实例

          原型模式可以说是“复制”，即克隆，但这个复制不是代码的复制，而是将对象包含的所有属性都创建一份拷贝。但不同的复制操作，可能会产生两种不同的拷贝，即浅拷贝和深拷贝。

          #include // 原型基类class Prototype {public:    virtual Prototype* clone() = 0;    virtual void show() = 0;};// 具体原型类 Aclass ConcretePrototypeA : public Prototype {public:    Prototype* clone() override {        return new ConcretePrototypeA(*this);    }    void show() override {        std::cout public:    Prototype* clone() override {        return new ConcretePrototypeB(*this);    }    void show() override {        std::cout     ConcretePrototypeA prototypeA;    Prototype* clonedA = prototypeA.clone();    clonedA-show();    delete clonedA;    ConcretePrototypeB prototypeB;    Prototype* clonedB = prototypeB.clone();    clonedB-show();    delete clonedB;    return 0;}public:    // 获取单实例    static Singleton* GetInstance();    // 释放单实例，进程退出时调用    static void deleteInstance();    // 打印实例地址    void Print();private:    // 将其构造和析构成为私有的, 禁止外部构造和析构    Singleton();    ~Singleton();    // 将其拷贝构造和赋值构造成为私有函数, 禁止外部拷贝和赋值    Singleton(const Singleton &signal);    const Singleton &operator=(const Singleton &signal);private:    // 唯一单实例对象指针    static Singleton *g_pSingleton;};    return g_pSingleton;}void Singleton::deleteInstance(){    if (g_pSingleton)    {        delete g_pSingleton;        g_pSingleton = nullptr;    }}void Singleton::Print(){    std::cout     std::cout     std::cout public:    static std::shared_ptr        std::cout         std::cout         std::cout     std::call_once(singletonFlag, [&] {        singleton = std::shared_ptr