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

小明 2025-05-05 01:45:45 5

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

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

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

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

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

文章目录

: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;
};
// 具体建造者类 A
class 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;
};
// 具体原型类 A
class 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

The End

标签：

便宜VPS

文章目录

😏1. 建造者模式

😊2. 原型模式

相关文章