c++设计模式-----工厂模式

《一》简单工厂模式

简单工厂模式是属于创建型模式，又叫做静态工厂方法(static Factory Method)模式，简单工厂模式是由一个工厂对象决定创建出来哪一种产品类的实例.

简单工厂模式的实质：是由一个工厂类根据传入的参数，动态决定应该创建哪一类产品类(这些产品类继承自一个父类或接口)的实例。打个比方假设有一个工厂，他能生产出A、B两种产品。当客户需要产品的时候一定要告诉共产是哪种产品，是A还是B。当新增加一种新产品的时候，那么就要去修改工厂的类。

简单工厂的缺点：当新增产品的时候就要去修改工厂的类，这就违反了开放封闭原则，(类、模块、函数)可以扩展，但是不可以修改

简单工厂模式原理：

class Product
{
public:
	Product(string name) :mname(name){}
	virtual ~Product(){}
	virtual void operation() = 0;
protected:
	string mname;
};
class ProductA :public Product
{
public:
	ProductA(string name) :Product(name){}
	void operation()
	{
		cout << mname << " operator xxxa" << endl;
	}
};
class ProductB :public Product
{
public:
	ProductB(string name) :Product(name){}
	void operation()
	{
		cout << mname << " operator xxxb" << endl;
	}
};
class ProductC : public Product
{
public:
	ProductC(string name) :Product(name){}
	void operation()
	{
		cout << mname << " operator xxxc" << endl;
	}
};
class SimpleFactory
{
public:
	Product* createProduct(int flag)
	{
		switch (flag)
		{
		case 1:
			return new ProductA("A");
			break;
		case 2:
			return new ProductB("B");
			break;
		default:
			return NULL;
			break;
		}
	}
};


int main()
{
	SimpleFactory f;
	Product* p = f.createProduct(2);//productB
	p->operation();
	return 0;
}

代码运行结果如下图：

《二》工厂方法模式：

所谓工厂方法模式，是指定义一个用于创建对象的接口，让子类决定实例化哪一个类。打个比方现在有A、B两种产品，那么久开两个工厂。工厂A负责生产A产品，工厂B负责生产B种产品。这时候客户不需要告诉工厂生产哪种产品了，只需要告诉工厂生产就可以了。

工厂模式原理:

工厂方法模式代码如下：

class Product
{
public:
	Product(string name) :mname(name){}
	virtual ~Product(){}
	virtual void operation() = 0;
protected:
	string mname;
};
class ProductA :public Product
{
public:
	ProductA(string name) :Product(name){}
	void operation()
	{
		cout << mname << " operator xxxa" << endl;
	}
};
class ProductB :public Product
{
public:
	ProductB(string name) :Product(name){}
	void operation()
	{
		cout << mname << " operator xxxb" << endl;
	}
};
class ProductC : public Product
{
public:
	ProductC(string name) :Product(name){}
	void operation()
	{
		cout << mname << " operator xxxc" << endl;
	}
};
class Factory
{
public:
	virtual ~Factory(){}
	virtual Product* createProduct() = 0;
};
class FactoryA :public Factory
{
public:
	Product* createProduct()
	{
		return new ProductA("A");
	}
};
class FactoryB :public Factory
{
public:
	Product* createProduct()
	{
		return new ProductB("B");
	}
};
class FactoryC :public Factory
{
public:
	Product* createProduct()
	{
		return new ProductC("C");
	}
};

int main()
{
	Factory* f = new FactoryC();
	Product* p = f->createProduct();
	p->operation();
	return 0;
}

代码运行结果如下：

《三》抽象工厂模式

为什么要有抽象工厂模式，假如我们A产品中有A1和A2两种型号的厂品，B产品中有B1和B2两种型号的厂品，那怎么办，上面两种工厂模式就不能解决了。这个时候抽象工厂模式就登场了。还是开设两家工厂，工厂A负责生产A1 、A2型号产品，B工厂负责生产B1、B2型号的产品。  

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。  适用性：一个系统要独立于它的产品的创建、组合和表示时。一个系统要由多个产品系列中的一个来配置时。当你要强调一系列相关的产品对象的设计以便进行联合使用时。当你提供一个产品类库，而只想显示它们的接口而不是实现时。

抽象工厂模式的原理图：

抽象工厂模式代码如下：

class ProductA
{
public:
	ProductA(string name) :mname(name){}
	virtual ~ProductA(){}
	virtual void operation() = 0;
protected:
	string mname;
};
class ProductA1 :public ProductA
{
public:
	ProductA1(string name) :ProductA(name){}
	void operation()
	{
		cout << mname << "operation a1" << endl;
	}
};
class ProductA2 :public ProductA
{
public:
	ProductA2(string name) :ProductA(name){}
	void operation()
	{
		cout << mname << "operation a2" << endl;
	}
};
class ProductB
{
public:
	ProductB(string name) :mname(name){}
	virtual ~ProductB(){}
	virtual void operation() = 0;
protected:
	string mname;
};
class ProductB1 :public ProductB
{
public:
	ProductB1(string name) :ProductB(name){}
	void operation()
	{
		cout << mname << "operation b1" << endl;
	}
};
class ProductB2 :public ProductB
{
public:
	ProductB2(string name) :ProductB(name){}
	void operation()
	{
		cout << mname << "operation b2" << endl;
	}
};
class AbstractFactory
{
public:
	virtual ~AbstractFactory(){}
	virtual ProductA* createProductA() = 0;
	virtual ProductB* createProductB() = 0;
};
class Factory1 : public AbstractFactory
{
public:
	virtual ProductA* createProductA()
	{
		return new ProductA1("a1");
	}
	virtual ProductB* createProductB()
	{
		return new ProductB1("b1");
	}
};
class Factory2 : public AbstractFactory
{
public:
	virtual ProductA* createProductA()
	{
		return new ProductA2("a2");
	}
	virtual ProductB* createProductB()
	{
		return new ProductB2("b2");
	}
};
int main()
{
	AbstractFactory* paf = new Factory2();
	ProductB* pa = paf->createProductB();
	pa->operation();

	AbstractFactory* paf1 = new Factory1();
	ProductA* pa1 = paf1->createProductA();
	pa1->operation();
	return 0;
}

代码运行结果如下：