创建型设计模式（共5种）

1、单例模式 Singleton

原理：私有化构造函数，禁止外部new；保证程序整个生命周期内，该类只能实例化出唯一一个对象；对外提供静态全局方法获取实例。C++11 推荐 Meyers 写法（静态局部变量），天然线程安全。 使用场景：日志管理器、全局配置类、数据库连接池、资源管理器。

#include <iostream>
using namespace std;

class Singleton
{
private:
    //私有构造，外部不能new
    Singleton() {}
public:
    //获取唯一实例
    static Singleton& getInstance()
    {
        static Singleton instance;
        return instance;
    }
    //禁用拷贝、赋值，防止生成副本
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    void work()
    {
        cout << "单例对象正在执行业务" << endl;
    }
};

int main()
{
    Singleton& s1 = Singleton::getInstance();
    Singleton& s2 = Singleton::getInstance();

    s1.work();
    cout << "s1地址:" << &s1 << endl;
    cout << "s2地址:" << &s2 << endl;

    return 0;
}

一句话归纳：全局只能生成一份对象，提供统一访问入口。

2、工厂方法 Factory‑Method

原理：定义一个工厂抽象基类，声明创建产品的接口；实例化产品的工作延迟交给各个子类工厂完成。上层代码只依赖抽象接口，不直接new具体产品，新增产品不用修改原有业务代码，满足开闭原则。 使用场景：多种协议解析器、不同硬件驱动、插件对象创建。

#include <iostream>
using namespace std;

//抽象产品
class Product
{
public:
    virtual void use() = 0;
    virtual ~Product() = default;
};

//具体产品A
class ProductA : public Product
{
public:
    void use() override
    {
        cout << "使用产品A" << endl;
    }
};

//具体产品B
class ProductB : public Product
{
public:
    void use() override
    {
        cout << "使用产品B" << endl;
    }
};

//抽象工厂
class Factory
{
public:
    virtual Product* createProduct() = 0;
    virtual ~Factory() = default;
};

//生产A的工厂
class FactoryA : public Factory
{
public:
    Product* createProduct() override
    {
        return new ProductA();
    }
};

//生产B的工厂
class FactoryB : public Factory
{
public:
    Product* createProduct() override
    {
        return new ProductB();
    }
};

int main()
{
    Factory* fac = new FactoryA();
    Product* p = fac->createProduct();
    p->use();

    delete p;
    delete fac;
    return 0;
}

一句话归纳：由子类工厂决定创建哪一款产品，对象创建与业务使用解耦。

3、抽象工厂 Abstract‑Factory

原理：工厂方法一次只能创建单个产品；抽象工厂用于创建一组相互配套、属于同一个家族的产品。一个工厂可以同时产出多个关联对象，保证这一套对象能够互相匹配使用。 使用场景：跨平台成套 UI 组件、客户端‑服务端一整套通信组件。

#include <iostream>
using namespace std;

//----------产品家族1：按钮----------
class Button
{
public:
    virtual void click() = 0;
    virtual ~Button() = default;
};
class WinButton : public Button
{
public:
    void click() override { cout << "Windows按钮被点击" << endl; }
};

//----------产品家族2：输入框----------
class TextBox
{
public:
    virtual void input() = 0;
    virtual ~TextBox() = default;
};
class WinTextBox : public TextBox
{
public:
    void input() override { cout << "Windows输入框" << endl; }
};

//----------抽象工厂：可以创建一整套组件----------
class AbstractFactory
{
public:
    virtual Button* createButton() = 0;
    virtual TextBox* createTextBox() = 0;
    virtual ~AbstractFactory() = default;
};

//Windows平台工厂，产出成套Windows组件
class WinFactory : public AbstractFactory
{
public:
    Button* createButton() override { return new WinButton(); }
    TextBox* createTextBox() override { return new WinTextBox(); }
};

int main()
{
    AbstractFactory* fac = new WinFactory();
    Button* btn = fac->createButton();
    TextBox* box = fac->createTextBox();

    btn->click();
    box->input();

    delete btn;
    delete box;
    delete fac;
    return 0;
}

一句话归纳：一次性创建一组配套的产品家族，保证多个对象兼容匹配。

4、建造者模式 Builder

原理：把复杂对象的构建过程和对象最终表示分离。对象由多个零件分步拼装而成；指挥者控制拼装步骤，建造者负责生产零件。同样的建造流程，可以拼装出配置不一样的对象。 使用场景：构造复杂网络报文、参数繁多的配置对象。

#include <iostream>
#include <string>
using namespace std;

//最终生成的复杂产品
class Product
{
public:
    string header;
    string body;
    void show()
    {
        cout << "报文头部:" << header << endl;
        cout << "报文载荷:" << body << endl;
    }
};

//建造者抽象
class Builder
{
public:
    virtual void buildHeader() = 0;
    virtual void buildBody() = 0;
    virtual Product* getResult() = 0;
    virtual ~Builder() = default;
};

//具体建造者
class PacketBuilder : public Builder
{
private:
    Product* product = new Product();
public:
    void buildHeader() override { product->header = "0xAA 0xBB"; }
    void buildBody() override { product->body = "业务数据内容"; }
    Product* getResult() override { return product; }
};

//指挥者：控制建造步骤顺序
class Director
{
public:
    void construct(Builder* builder)
    {
        builder->buildHeader();
        builder->buildBody();
    }
};

int main()
{
    Director dir;
    Builder* builder = new PacketBuilder();
    dir.construct(builder);

    Product* pkt = builder->getResult();
    pkt->show();

    delete pkt;
    delete builder;
    return 0;
}

一句话归纳：分步组装零件，生成结构复杂的对象。

5、原型模式 Prototype

原理：不通过new从头创建对象；以一个已经存在的原型对象为模板，克隆复制一份新对象；分为浅拷贝、深拷贝；当对象初始化开销很大时，可以节省创建成本。 使用场景：创建对象耗时高、大量对象字段重复、需要快速复制实例。

#include <iostream>
#include <string>
using namespace std;

//原型抽象类
class Prototype
{
public:
    string info;
    virtual Prototype* clone() = 0;
    virtual ~Prototype() = default;
    void show()
    {
        cout << "对象信息:" << info << endl;
    }
};

//具体原型
class ConcretePrototype : public Prototype
{
public:
    ConcretePrototype(string s) { info = s; }
    //拷贝构造完成克隆
    Prototype* clone() override
    {
        return new ConcretePrototype(*this);
    }
};

int main()
{
    Prototype* origin = new ConcretePrototype("原始模板对象");
    Prototype* copyObj = origin->clone();

    origin->show();
    copyObj->show();

    delete origin;
    delete copyObj;
    return 0;
}

一句话归纳：以克隆已有对象的方式快速生成新实例。