c++ 设计模式之 简单工厂，工厂模式，抽象工厂

一、简单工厂  （参数化工厂）

参数化的工厂方法，由不同参数决定创建何种对象，通常一个工厂创建多种对象

一个工厂类通过传入不同枚举值，创建不同类型的产品

#include<iostream>

//父类（接口类）
class Product
{
public:
    virtual void show() = 0;
    virtual ~Product(){};
}
//子类1（实现类）
class Product1:public Product
{
public:
    virtual void show() override
{
    cout<<"product1"<<endl;
}

}
//子类2（实现类）
class Product1:public Product
{
public:
    virtual void show() override
{
    cout<<"product2"<<endl;
}

}


enum  ProductType
{
	first,
	second
};

//工厂类
class Factory
{
public:
	Product* CreateProduct(ProductType type)
	{
		switch (type)
		{
		case first:
			return new Product1();
		case second:
			return new Product2();
		default:
			return NULL;
		break;
		}
	};
}

int main()
{
    Factory factory;

    //实现产品1
    Product *pro1 = factory.CreateProduct(first);
    pro->show();

    //实现产品2
    Product *pro2 = factory.CreateProduct(second);
    pro->show();
}

优点：结构简单，管理方式简单
缺点：扩展性非常差，新增产品的时候，需要去修改工厂类。

当需要增加新产品（factory3）时，需要修改简单工厂 增加if else 这样违背了六大设计原则之中的 “开闭原则”(即对扩展开放,对修改关闭的原则)。因此下面改为用工厂方法模式实现

二、工厂方法   （工厂模式或者多态工厂模式）

与简单工厂相比，提供一个工厂类接口，然后为每个产品都继承实现一个工厂子类，然后通过不同产品工厂子类创建不同类型的产品。

#include<iostream>

//父类（接口类）
class Product
{
public:
    virtual void show() = 0;
    virtual ~Product(){};
}
//子类1（实现类）
class Product1:public Product
{
public:
    virtual void show() override
{
    cout<<"product1"<<endl;
}

}
//子类2（实现类）
class Product1:public Product
{
public:
    virtual void show() override
{
    cout<<"product2"<<endl;
}

}



//工厂类(接口类)
class Factory
{
public:
	virtual Product* CreateProduct() = 0;
}

//产品1工厂类
class Product1_Factory
{
public:
	virtual Product* CreateProduct() override
    {
        return new Product1();
    }
}

//产品2工厂类
class Product2_Factory
{
public:
	virtual Product* CreateProduct() override
    {
        return new Product2();
    }
}


int main()
{
    //实现产品1
    Factory factory1 = new Product1_Factory();
    Product *pro1 = factory1.CreateProduct();
    pro1->show();

    //实现产品2
    Factory factory2 = new Product2_Factory();
    Product *pro2 = factory2.CreateProduct();
    pro2->show();
}

工厂方法模式很好的避免了过多的else if语句，同时也保证了开-闭原则，但是当类过多时会产生类"爆炸"的情况，所以具体选用什么模式需要根据实际需求进行取舍。

工厂方法的缺点：
每新增一个产品，就需要增加一个对应的产品的具体工厂类。相比简单工厂模式而言，工厂方法模式需要更多的类定义。
一条生产线只能一个产品。

上面两种模式不管工厂怎么拆分抽象，都只是针对一类产品，如果需要多种产品，那就需要使用抽象工厂模式

三、抽象工厂 (称：“家族工厂”更贴切)

抽象工厂与工厂方法相比，抽象工厂允许生成不同的产品(即一个工厂存在多个产品)。

不同子类工厂，实现不同家族多个产品。例如：产品1 ，产品2 在工厂1（北京）和工厂2（上海）不同地区的销售价格不一样时，

工厂1传入产品1 ，产品2特定价格，

工厂2传入产品1 ，产品2特定价格

代码如下所示:

#include <iostream>
using namespace std;
class Product
{
public:
    virtual ~Product() {}
    // 纯虚函数
    virtual void Create(string content) = 0;
};
class ProductA : public Product
{
public:
    void Create(string content) override {
        cout << "ProductA " << content << endl;
    }
};
class ProductB : public Product
{
public:
    void Create(string content) override {
        cout << "ProductB " << content << endl;
    }
};
class Factory
{
public:
    virtual Product* CreateProductA() = 0;
    virtual Product* CreateProductB() = 0;
    Product* m_pProductA;
    Product* m_pProductB;
    virtual ~Factory() {
        if (m_pProductA)
            delete m_pProduct;
        if(m_pProductB)
            delete m_pProductB;
    }
};
class FactorySubOne : public Factory
{
public:
    virtual Product* CreateProductA() override{
        return m_pProductA = new ProductA();
    }
    virtual Product* CreateProductB() override {
        return m_pProductB = new ProductB();
    }
};
class FactorySubTwo : public Factory
{
public:
    virtual Product* CreateProductA() override{
        return m_pProductA = new ProductA();
    }
    virtual Product* CreateProductB() override {
        return m_pProductB = new ProductB();
    }
};
int main()
{
    FactorySubOne factroy_sub_one;
    FactorySubTwo factroy_sub_two;
    factroy_sub_one.CreateProductA()->Create("FactorySubOne  A");
    factroy_sub_one.CreateProductB()->Create("FactorySubOne  B");
    factroy_sub_two.CreateProductA()->Create("FactorySubTwo A");
    factroy_sub_two.CreateProductB()->Create("FactorySubTwo B");
    system("pause");
}