C++单例模式与工厂模式

一、单例模式

理解C++单例模式之前，需要

参考自：C++ 静态成员变量_Little_XWB的博客-CSDN博客_c++静态成员变量

C++如何实现单例模式？_Tattoo_Welkin的博客-CSDN博客_单例模式c++实现

C++实现单例的5种方法总结_zztan的博客-CSDN博客_c++ 单例

C++类的单例模式_night boss的博客-CSDN博客_c++单例模式

C++如何用虚继承实现单例？ - 知乎

1.饿汉式

class Singleton {
private:
    static Singleton instance;
    Singleton() {}
public:
    static Singleton& GetInstance() {
        return instance;
    } 
    void print() {
        cout << "123" << endl;
    }
    int i=1;
 
};
Singleton Singleton::instance;//类中声明，类外定义
int main()
{
 
    Singleton::GetInstance().print();
    cout << Singleton::GetInstance().i << endl;
    return 0;
}

饿汉式在编译时便将静态对象放到全局区了。

2.懒汉式

class Singleton {
private:
    Singleton() {}
public:
    static Singleton& GetInstance() {
        static Singleton instance;
        return instance;
    }
    void print() {
        cout << "123" << endl;
    }
    int i = 0;
};
int main()
{
 
    Singleton::GetInstance().print();
    cout << Singleton::GetInstance().i << endl;
    return 0;
}

在这懒汉式用的是静态局部变量的方法，充分使用了静态局部变量的特点。当然也可以使用new的方式，就是比较麻烦得记得delete。

3.注册式单例

这个比较复杂些，是一种可继承的单例，需要用到模板

template<typename T>
class SingletonBase {
protected:
    //得声明为protected
    SingletonBase(){}
public:
    static T& GetInstance() {
        static T instance;
        return instance;
    }
};
class Foo :public SingletonBase {
private:
 
public:
    static void print() {
        cout << "123" << endl;
    }
};
int main()
{
     Foo::GetInstance().print();
}

4.补充

C#类型的单例模式可参考：c# 单例模式的实现

C#当中弱化了全局变量的声明与定义的概念，用C#写单例也相对简单的多

二、工厂模式

工厂模式 中对象的创建过程是我们不需要去关心的，而我们注重的是对象的实际操作，所以，我们需要分离对象的创建和操作两部分，如此，方便后期的程序扩展和维护。

参考自：

C++ 工厂模式解决什么问题？ - 明明1109 - 博客园

C++实现工厂模式_herryone123的博客-CSDN博客_c++工厂模式

1.简单工厂

1）基本要素：抽象产品类、具体产品类、一个简单工厂类

2）代码

class ItemBase {//抽象产品类
public:
    virtual void ItemName() = 0;
    virtual ~ItemBase() {};//声明析构函数为虚函数，防止内存泄漏
};
class ItemA :public ItemBase {//具体产品类A
public:
     void  ItemName() override{
         cout << "ItemA" << endl;
    }
};
class ItemB :public ItemBase {//具体产品类B
public:
    void  ItemName() override {
        cout << "ItemB" << endl;
    }
};
class ItemFactory {//简单工厂类
public:
    ItemBase* CreateItem(bool ItemTypeIsA) {
        switch (ItemTypeIsA) {
        case 1:
            return new ItemA();
        default:
            return new ItemB();
        }
    }
};
int main()
{
    ItemFactory itemFactory;
    ItemBase* itemA = itemFactory.CreateItem(1);
    itemA->ItemName();
 
    ItemBase* itemB = itemFactory.CreateItem(0);
    itemB->ItemName();
}

2.工厂方法

1）基本要素：抽象产品类、具体产品类、抽象工厂类、具体工厂类。每个具体工厂只能生产一种具体的产品

2）代码

class ItemBase {//抽象产品基类
public:
    virtual void ItemName() = 0;
    virtual ~ItemBase() {};//声明析构函数为虚函数，防止内存泄漏
};
class ItemA :public ItemBase {//具体产品类A
public:
     void  ItemName() override{
         cout << "ItemA" << endl;
    }
};
class ItemB :public ItemBase {//具体产品类B
public:
    void  ItemName() override {
        cout << "ItemB" << endl;
    }
};
 
class ItemFactoryBase {//抽象工厂基类
public:
    virtual ItemBase* CreateItem() = 0;
    virtual ~ItemFactoryBase() {};
};
class ItemAFactory :public ItemFactoryBase {//具体工厂类A
public :
    ItemBase* CreateItem()override {
        return new ItemA();
    }
};
class ItemBFactory :public ItemFactoryBase {//具体工厂类B
public:
    ItemBase* CreateItem()override {
        return new ItemB();
    }
};
int main()
{
    ItemFactoryBase* itemAFactory = new ItemAFactory();
    ItemBase* itemA = itemAFactory->CreateItem();
    itemA->ItemName();
 
    ItemFactoryBase* itemBFactory = new ItemBFactory();
    ItemBase* itemB=itemBFactory->CreateItem();
    itemB->ItemName();
}

3.抽象工厂

1）基本要素：抽象产品类、具体产品类、抽象工厂类、具体工厂类。一个具体的工厂可以生产多个具体产品。

2）代码

class ShoesBase {//鞋子抽象类
public:
    virtual void ShoesName() = 0;
    virtual ~ShoesBase() {};//声明析构函数为虚函数，防止内存泄漏
};
class ShoesA :public ShoesBase {//具体产品类--鞋子A
public:
     void  ShoesName() override{
         cout << "ShoesA" << endl;
    }
};
class ShoesB :public ShoesBase {//具体产品类--鞋子B
public:
    void  ShoesName() override {
        cout << "ShoesB" << endl;
    }
};
 
class HatBase {//帽子抽象类
public:
    virtual void HatName() = 0;
    virtual ~HatBase() {};//声明析构函数为虚函数，防止内存泄漏
};
class HatA :public HatBase {//具体产品类--帽子A
public:
    void  HatName() override {
        cout << "HatA" << endl;
    }
};
class HatB :public HatBase {//具体产品类--帽子B
public:
    void  HatName() override {
        cout << "HatB" << endl;
    }
};
 
 
 
 
class FactoryBase {//抽象工厂类，可生产多种产品
public:
    virtual ShoesBase* CreateShoes() = 0;
    virtual HatBase* CreateHat() = 0;
    virtual ~FactoryBase() {};
};
class AFactory :public FactoryBase {//具体工厂类A，可生成所有的A类型的产品
public :
    ShoesBase* CreateShoes()override {
        return new ShoesA();
    }
    HatBase* CreateHat()override {
        return new HatA();
    }
};
class BFactory :public FactoryBase {//具体工厂类B，可生成所有的B类型的产品
public:
    ShoesBase* CreateShoes()override {
        return new ShoesB();
    }
    HatBase* CreateHat()override {
        return new HatB();
    }
};
int main()
{
    FactoryBase* aFactory = new AFactory();//创建A类工厂
    ShoesBase* shoesA = aFactory->CreateShoes();
    shoesA->ShoesName();
    HatBase* hatA = aFactory->CreateHat();
    hatA->HatName();
 
    FactoryBase* bFactory = new BFactory();//创建B类工厂
    ShoesBase* shoesB = bFactory->CreateShoes();
    shoesB->ShoesName();
    HatBase* hatB = bFactory->CreateHat();
    hatB->HatName();
}