创建型设计模式-单例模式/工厂模式/抽象工厂

class Singleton {
public:
  static Singleton * GetInstance() {
    if (_instance == nullptr) {
    _instance = new Singleton();
  }
    return _instance;
  }
private:
  Singleton(){}; //构造
  ~Singleton(){};
  Singleton(const Singleton &) = delete; //拷⻉ 构造
  Singleton& operator=(const Singleton&) = delete;//拷贝赋值构造
  Singleton(Singleton &&) = delete;//移动构造
  Singleton& operator=(Singleton &&) = delete;//移动拷贝构造
  static Singleton * _instance;
};
Singleton* Singleton::_instance = nullptr;//静态成员需要初始化

#include <iostream>
using namespace std;
class Singleton
{
public:
  static Singleton* instance = new Singleton();//提前实例化
    static Singleton* GetInstance() {
        return instance;
    }
private:
    Singleton(){}; //构造
    ~Singleton(){};
    Singleton(const Singleton &) = delete; //拷⻉  构造
    Singleton& operator=(const Singleton&) =
            delete;//拷贝赋值构造
            Singleton(Singleton &&) = delete;//移动构造
            Singleton& operator=(Singleton &&) =
                    delete;//移动拷贝构造
};
int main() {
    Singleton* test1 = Singleton::GetInstance();
    cout << test1 << endl;
    Singleton* test2 = Singleton::GetInstance();
    cout << test2 << endl;
    return 0;
}

#include <mutex>
class Singleton { // 懒汉模式 lazy load
public:
static Singleton * GetInstance() {
//在外面加锁会造成锁资源浪费，，每次调用都会调用锁。
//我们其实只需要第一次调用的时候才需要锁，其他时候是不需要的
if (_instance == nullptr) {
  std::lock_guard<std::mutex> lock(_mutex); // 双重检测可以避免第一次读的时候多个线程进入的问题。
  if (_instance == nullptr) {
    _instance = new Singleton();
  }
}
  return _instance;
}
private:
static void Destructor() {
  if (nullptr != _instance) {
    delete _instance;
    _instance = nullptr;
  }
}
Singleton(){}; //构造
~Singleton(){};
Singleton(const Singleton &) = delete; //拷⻉构造
Singleton& operator=(const Singleton&) = delete;//拷贝赋值构造
Singleton(Singleton &&) = delete;//移动构造
Singleton& operator=(Singleton &&) = delete;//移动拷贝构造
static Singleton * _instance;
static std::mutex _mutex;
};
Singleton* Singleton::_instance = nullptr;//静态成员需要初始化
std::mutex Singleton::_mutex; //互斥锁初始化

#include <iostream>
enum ProductType
{
    PRODUCT_A,
    PRODUCT_B
};
// 产品基类
class Product
{
public:
    virtual void Show() = 0;
};
// 产品 A
class ProductA : public Product
{
public:
    void Show()
    {
        std::cout << "Product A." << std::endl;
    }
};
// 产品 B
class ProductB : public Product
{
public:
    void Show()
    {
        std::cout << "Porduct B." << std::endl;
    }
};
// 工厂
class Factory
{
public:
    Product* Create(int type)
    {
        switch(type)
        {
            case PRODUCT_A : return new ProductA; break;
            case PRODUCT_B : return new ProductB; break;
            default : break;
        }
    }
};
int main()
{
    Factory *factory = new Factory();
    factory->Create(PRODUCT_A)->Show();
    factory->Create(PRODUCT_B)->Show();
    return 0;
}

#include <iostream>
// 产品基类
class Product
{
public:
    virtual void Show() = 0;
};
// 工厂基类
class Factory
{
public:
    virtual Product* Create() = 0;
};
// 产品 A
class ProductA : public Product
{
public:
    void Show()
    {
        std::cout << "Product A." << std::endl;
    }
};
// 产品 B
class ProductB : public Product
{
public:
    void Show()
    {
        std::cout << "Porduct B." << std::endl;
    }
};
// 工厂 A
class FactoryA : public Factory
{
public:
    Product* Create()
    {
        return new ProductA;
    }
};
// 工厂 B
class FactoryB : public Factory
{
public:
    Product* Create()
    {
        return new ProductB;
    }
};
int main()
{
    FactoryA *factoryA = new FactoryA();
    FactoryB *factoryB = new FactoryB();
    factoryA->Create()->Show();
    factoryB->Create()->Show();
    return 0;
}

#include <iostream>
// Product A
class ProductA
{
public:
    virtual void Show() = 0;
};
class ProductA1 : public ProductA
{
public:
    void Show()
    {
        std::cout << "Product A1." << std::endl ;
    }
};
class ProductA2 : public ProductA
{
public:
    void Show()
    {
        std::cout << "Product A2." << std::endl ;
    }
};
// Product B
class ProductB
{
public:
    virtual void Show() = 0;
};
class ProductB1 : public ProductB
{
public:
    void Show()
    {
        std::cout << "Product B1." << std::endl ;
    }
};
class ProductB2 : public ProductB
{
public:
    void Show()
    {
        std::cout << "Product B2." << std::endl ;
    }
};
// Factory
class Factory
{
public:
    virtual ProductA* CreateProductA() = 0;
    virtual ProductB* CreateProductB() = 0;
};
class Factory1 : public Factory
{
public:
    ProductA* CreateProductA()
    {
        return new ProductA1();
    }
    ProductB* CreateProductB()
    {
        return new ProductB1();
    }
};
class Factory2 : public Factory
{
    ProductA* CreateProductA()
    {
        return new ProductA2();
    }
    ProductB* CreateProductB()
    {
        return new ProductB2();
    }
};
int main()
{
    Factory  *factoryObj1  = new Factory1();
    ProductA *productObjA1 = factoryObj1->CreateProductA();
    ProductB *productObjB1 = factoryObj1->CreateProductB();
    productObjA1->Show();
    productObjB1->Show();
    Factory  *factoryObj2  = new Factory2();
    ProductA *productObjA2 = factoryObj2->CreateProductA();
    ProductB *productObjB2 = factoryObj2->CreateProductB();
    productObjA2->Show();
    productObjB2->Show();
    return 0;
}