设计模式

单例模式

应用：常用于管理资源，如日志、线程池

class Singleton{
public:
    static Singleton& getInstance(){
        static Singleton instance;
        return instance;
    }
    void printTest(){
        cout<<"do something"<

工厂模式

简单工厂模式、工厂方法模式、抽象工厂模式
作用：封装对象的创建，分离对象的创建和操作过程，用于批量管理对象的创建过程，便于程序的维护和扩展。

1. 简单工厂模式

//简单工厂模式
typedef enum ProductTypeTag
{
    TypeA,
    TypeB,
    TypeC
}PRODUCTTYPE;

class Product//产品抽象基类
{
public:
    virtual void Show() = 0;
};

class ProductA : public Product
{
public:
    void Show()
    {
    cout<<"I'm ProductA"<Show();
    productB->Show();
    productC->Show();
if(productA){
    delete productA;
    productA=NULL;
}
if(productB){
    delete productB;
    productB=NULL;
}
if(productC){
    delete productC;
    productC=NULL;
}
return 0;
}

2. 工厂方法模式
   其实这才是正宗的工厂模式，简单工厂模式只是一个简单的对创建过程封装。工厂方法模式在简单工厂模式的基础上增加对工厂的基类抽象，不同的产品创建采用不同的工厂创建（从工厂的抽象基类派生），这样创建不同的产品过程就由不同的工厂分工解决：FactoryA专心负责生产ProductA，FactoryB专心负责生产ProductB，FactoryA和FactoryB之间没有关系；如果到了后期，如果需要生产ProductC时，我们则可以创建一个FactoryC工厂类，该类专心负责生产ProductC类产品。
   该模式相对于简单工厂模式的优势在于：便于后期产品种类的扩展。

//工厂方法模式
typedef enum ProductTypeTag
{
    TypeA,
    TypeB,
    TypeC
}PRODUCTTYPE;
class Product//产品抽象基类
{
    public:
    virtual void Show() = 0;
};
class ProductA : public Product
{
public:
    void Show()
    {
        cout<<"I'm ProductA"<createProduct();
    productA->Show();
    Factory *factoryB=new FactoryB();
    Product *productB = factoryB->createProduct();
    productB->Show();
    if (factoryA)
    {
        delete factoryA;
        factoryA = NULL;
    }
    if (factoryB)
    {
        delete factoryB;
        factoryB = NULL;
    }
    if (productA)
    {
        delete productA;
        productA = NULL;
    }
    if (productB)
    {
        delete productB;
        productB = NULL;
    }
    return 0;
}

3.抽象工厂模式
抽象工厂模式对工厂方法模式进行了更加一般化的描述。工厂方法模式适用于产品种类结构单一的场合，为一类产品提供创建的接口；而抽象工厂方法适用于产品种类结构多的场合，就是当具有多个抽象产品类型时，抽象工厂便可以派上用场。

抽象工厂模式更适合实际情况，受生产线所限，让低端工厂生产不同种类的低端产品，高端工厂生产不同种类的高端产品。

//抽象工厂模式
class ProductA
{
public:
    virtual void Show() = 0;
};

class ProductA1 : public ProductA//A类低端产品
{
public:
    void Show()
    {
        cout<<"I'm ProductA1"<CreateProductA();
    ProductB *productB1 = factory1->CreateProductB();
    productA1->Show();
    productB1->Show();
    Factory *factory2 = new Factory2();
    ProductA *productA2 = factory2->CreateProductA();
    ProductB *productB2 = factory2->CreateProductB();
    productA2->Show();
    productB2->Show();
if (factory1)
{
delete factory1;
factory1 = NULL;
}
if (productA1)
{
delete productA1;
productA1= NULL;
}
if (productB1)
{
delete productB1;
productB1 = NULL;
}
if (factory2)
{
delete factory2;
factory2 = NULL;
}
if (productA2)
{
delete productA2;
productA2 = NULL;
}
if (productB2)
{
delete productB2;
productB2 = NULL;
}
}