C++ 工厂模式

简单工厂模式

优点：
1、工厂类中包含了必要的逻辑判断，可以根据用户的需求动态实例化相关的类。2、对客户端来说，去除了与具体产品的依赖。
缺点：
1、违背开放-封闭原则，添加新的产品时需要修改工厂类的内容。
2、要求产品子类的类型差不多，使用的方法名都相同。如果类比较多，而所有的类又必须要添加一种方法，会非常麻烦。

所以简单工厂模式一般应用于多种同类型类的情况，将这些类隐藏起来，再提供统一的接口，便于维护和修改。

工厂模式

相比简单工厂模式遵循了开放-封闭原则，使得模式的灵活性更强。

简单工厂和工厂模式代码：

#include <iostream>

//声明抽象产品类
class abstract_product;
//抽象工厂类 - 生产产品：使用类型区分
class abstract_factory
{
public:
	abstract_factory(void){}
	~abstract_factory(void){}
	
public:
	virtual abstract_product *create_product(int type)=0;
};
//抽象工厂类
class abstract_factory_ex
{
public:
	abstract_factory_ex(void){}
	~abstract_factory_ex(void){}
	
public:
	virtual abstract_product *create_product(void)=0;
};
//抽象产品类
class abstract_product
{
public:
	abstract_product(void){}
	~abstract_product(void){}
	
public:
	virtual void opt(void) = 0;
};

//产品A类
class product_a : public abstract_product
{
public:
	product_a(void){}
	~product_a(void){}
	
public:
	virtual void opt(void)
	{
		std::cout << "product_a opt .." << std::endl;
	}
};
//产品B类
class product_b : public abstract_product
{
public:
	product_b(void){}
	~product_b(void){}
	
public:
	virtual void opt(void)
	{
		std::cout << "product_b opt .." << std::endl;
	}
};
//简单工厂模式
class simple_factory : public abstract_factory
{
public:
	simple_factory(void){}
	~simple_factory(void){}
	
public:
	virtual abstract_product *create_product(int type)
	{
		abstract_product *product = NULL;
		switch(type)
		{
		case 1:
			product = new product_a;
			break;
		case 2:
			product = new product_b;
			break;
		default:
			break;
		}
		return product;
	}
};
//工厂模式
class factory_a : public abstract_factory_ex
{
public:
	factory_a(void){}
	~factory_a(void){}
	
public:
	virtual abstract_product *create_product(void)
	{
		return new product_a;
	}
};
class factory_b : public abstract_factory_ex
{
public:
	factory_b(void){}
	~factory_b(void){}
	
public:
	virtual abstract_product *create_product(void)
	{
		return new product_b;
	}
};

int main()
{
	std::cout << "start-up .." << std::endl;
	
	std::cout << "************* SimpleFactory mode *******************" << std::endl;
	simple_factory s_factory;
	abstract_product *s_product_a = s_factory.create_product(1);
	abstract_product *s_product_b = s_factory.create_product(2);
	
	if(s_product_a)
	{
		s_product_a->opt();
		delete s_product_a;
	}
	if(s_product_b)
	{
		s_product_b->opt();
		delete s_product_b;
	}
	
	std::cout << "************* Factory mode *******************" << std::endl;
	
	factory_a f_a;
	factory_b f_b;
	s_product_a = f_a.create_product();
	s_product_b = f_b.create_product();
	
	if(s_product_a)
	{
		s_product_a->opt();
		delete s_product_a;
	}
	if(s_product_b)
	{
		s_product_b->opt();
		delete s_product_b;
	}
	
	std::cout << "done .." << std::endl;
    return 0;
}

抽象工厂模式

抽象工厂模式提供创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
当存在多个产品系列，而客户端只使用一个系列的产品时，可以考虑使用抽象工厂模式。

缺点：
1、当增加一个新系列的产品时，不仅需要现实具体的产品类，还需要增加一个新的创建接口，扩展相对困难而且违背了开放-封闭原则。所以一般适用于产品组合产品族变化不大的情况。
2、结构太过臃肿，如果产品类型比较多，或者产品族类比较多，就会非常难于管理。