设计模式——工厂模式

工厂模式

工厂模式就是将对象实例化的过程封装起来，成批次的构造对象。

应用情景小故事：

假设有个刚起步的加工儿童男装小手工作坊，此时生产还比较单一，只能加工一款式A。大多客户都是散户，订单也很少，随来订单随做。

那此时的模式结构如下图：

#include <iostream>
using namespace std;

class ClothBoy  
{  
public:  
	virtual ~ClothBoy() = 0;
protected:
	ClothBoy(){cout<<"ClothBoy..."<<endl;}
};  
//A款 
class ClothBoyA: public ClothBoy  
{  
public:  
	~ClothBoyA(){ cout<<"~ClothBoyA..."<<endl;};
	 ClothBoyA(){ cout<<"ClothBoyA..."<<endl;}
protected:
private:
};  

int main(){
	ClothBoyA *a = new ClothBoyA();
	ClothBoyA *b = new ClothBoyA();
	return 0;
}

此模式的缺点就是什么事情都亲力亲为，生成过程完全暴漏在外，随着作坊的发展，订单量也越来越大，此种模式的控制变得越来越复杂。既要接订单又要手工生产，忙的不亦乐乎，几个手下也起了抱怨。老板一咬牙一跺脚“反正渠道为王，咱们现在有了订单和渠道了，以后我们光接订单，其他的生产找工厂代工就行”说干就干，没两天就有模有样的整起来了。

#include <iostream>
using namespace std;

class ClothBoy  
{  
public:  
	virtual ~ClothBoy() = 0;
protected:
	ClothBoy(){cout<<"ClothBoy..."<<endl;}
};  
//A款 
class ClothBoyA: public ClothBoy  
{  
public:  
	~ClothBoyA(){ cout<<"~ClothBoyA..."<<endl;};
	 ClothBoyA(){ cout<<"ClothBoyA..."<<endl;}
protected:
private:
};  

///工厂类
class Factory
{
public:
   ~Factory(){cout<<"~Factory....."<<endl;};
	Factory(){cout<<"Factory....."<<endl;};
	ClothBoy* CreateClothBoyA(){return new ClothBoyA();};
private:
};

int main(){
	Factory *factory = new Factory();
	ClothBoy *a = factory->CreateClothBoyA();
	return 0;
}

以上所做的改变只是把ClothBoy的A款的new 封装了起来。想象一下，随着市场份额的加大，消费者也不满足于单一的款式，所以公司决定开发B款，以丰富款式。

问题来了：B款的生产怎么解决

1 找另一家工厂代工？（多态，类继承层次，以新建一个类为代价）

2 还由A款工产，采用另一条生产流水线？（两条流水线相差无几啊，重复）

传递参数：
#include <iostream>
#include <string>
using namespace std;

class ClothBoy  
{  
public:  
	virtual ~ClothBoy() = 0{};
protected:
	ClothBoy(){cout<<"ClothBoy..."<<endl;}
};  
//A款
class ClothBoyA: public ClothBoy  
{  
public:  
   ~ClothBoyA(){ cout<<"~ClothBoyA..."<<endl;};
	ClothBoyA(){ cout<<"ClothBoyA..."<<endl;}
protected:
private:
};  

//B款
class clothBoyB: public ClothBoy
{
public:
	~clothBoyB(){ cout<<"~ClothBoyB..."<<endl;};
	clothBoyB(){ cout<<"ClothBoyB..."<<endl;};
protected:
private:
};

//工厂
class Factory
{
public:
	~Factory(){cout<<"~Factory....."<<endl;};
	Factory(){cout<<"Factory....."<<endl;};
	ClothBoy* CreateClothBoy(string type)
	{
		if (type == "")
		{
			return NULL;
		}else if (type == "ClothBoyA")
		{
			return new ClothBoyA();
		}else if (type == "ClothBoyB")
		{
			return new clothBoyB();
		}
		
	};
private:
};

int main(){
	Factory *myfactory = new Factory();
	ClothBoy *a = myfactory->CreateClothBoy("ClothBoyA");
	ClothBoy *b = myfactory->CreateClothBoy("ClothBoyB");
	return 0;
}

至此为止，我们仅完成了factory模式的其中一个功能：封装了对象的创建
还有另外一个重要的功能，具体化类的工作延迟的子类中，因为面向对象设计原则有一条是面向抽象编程，所以：

#include <iostream>
#include <string>
using namespace std;

class ClothBoy  
{  
public:  
	virtual ~ClothBoy() = 0{};
protected:
	ClothBoy(){cout<<"ClothBoy..."<<endl;}
};  
//A款
class ClothBoyA: public ClothBoy  
{  
public:  
   ~ClothBoyA(){ cout<<"~ClothBoyA..."<<endl;};
	ClothBoyA(){ cout<<"ClothBoyA..."<<endl;}
protected:
private:
};  

//B款
class clothBoyB: public ClothBoy
{
public:
	~clothBoyB(){ cout<<"~ClothBoyB..."<<endl;};
	clothBoyB(){ cout<<"ClothBoyB..."<<endl;};
protected:
private:
};

//工厂
class Factory
{
public:
	virtual ~Factory() = 0{};
	virtual ClothBoy* CreateClothBoy(string type) = 0;
protected:
	Factory(){cout<<"Factory....."<<endl;};
private:
};

class ConcreteFactory:public Factory
{
public:
	~ConcreteFactory(){ cout<<"~ConcreteFactory..."<<endl;};
	ConcreteFactory(){cout<<"ConcreteFactory....."<<endl;};

	ClothBoy* CreateClothBoy(string type)
	{
		if (type == "")
		{
			return NULL;
		}else if (type == "ClothBoyA")
		{
			return new ClothBoyA();
		}else if (type == "ClothBoyB")
		{
			return new clothBoyB();
		}

	};
protected:	
private:
};
int main(){
	Factory *myfactory = new ConcreteFactory();
	ClothBoy *a = myfactory->CreateClothBoy("ClothBoyA");
	ClothBoy *b = myfactory->CreateClothBoy("ClothBoyB");
	return 0;
}

再随着公司发展，不仅仅生产男童的服装了，要增加女童服装的生产了。这时候上面的factory就不能堪当大任了，因为它只能局限一种类。此时应使用abstract factory模式：

#include <iostream>
#include <string>

using namespace std;

class ClothBoy
{
public:
	virtual ~ClothBoy(){};
protected:
	ClothBoy(){};
private:
};

class ClothGirl
{
public:
	virtual ~ClothGirl(){};
protected:
	ClothGirl(){};
private:
};

class ClothBoyA:public ClothBoy
{
public:
	ClothBoyA(){cout<<"ClothBoyA..."<<endl;};
	~ClothBoyA(){};
protected: 
private:
};

class ClothBoyB:public ClothBoy
{
public:
	ClothBoyB(){cout<<"ClothBoyB..."<<endl;};
	~ClothBoyB(){};
protected: 
private:
};

class ClothGirlA:public ClothGirl
{
public:
	ClothGirlA(){cout<<"ClothGirlA..."<<endl;};
	~ClothGirlA(){};
protected:
private:
};
class ClothGirlB:public ClothGirl
{
public:
	ClothGirlB(){cout<<"ClothGirlB..."<<endl;};
	~ClothGirlB(){};
protected:
private:
};

class AbstractFactory
{
public:
	virtual ~AbstractFactory(){};
	virtual ClothBoy* CreateClothBoy(string type) = 0;
	virtual ClothGirl* CreateClothGirl(string type) = 0;
protected:
	AbstractFactory(){};
private:
};

class ConcreteFactory1:public AbstractFactory
{
public:
	ConcreteFactory1(){};
	~ConcreteFactory1(){};
	ClothBoy* CreateClothBoy(string type){
		if (type == "")
	{
		return NULL;
	}else if (type == "ClothBoyA")
	{
		return new ClothBoyA();
	}else if (type == "ClothBoyB")
	{
		return new ClothBoyB();
	}
	};
	ClothGirl* CreateClothGirl(string type){ 
		if (type == "")
	{
		return NULL;
	}else if (type == "ClothGirlA")
	{
		return new ClothGirlA();
	}else if (type == "ClothGirlB")
	{
		return new ClothGirlB();
	}
	};
protected:
private:
};

class ConcreteFactory2:public AbstractFactory
{
public:
	ConcreteFactory2(){};
	~ConcreteFactory2(){};
	ClothBoy* CreateClothBoy(string type){
		if (type == "")
		{
			return NULL;
		}else if (type == "ClothBoyA")
		{
			return new ClothBoyA();
		}else if (type == "ClothBoyB")
		{
			return new ClothBoyB();
		}
	};
	ClothGirl* CreateClothGirl(string type){ 
		if (type == "")
		{
			return NULL;
		}else if (type == "ClothGirlA")
		{
			return new ClothGirlA();
		}else if (type == "ClothGirlB")
		{
			return new ClothGirlB();
		}
	};
protected:
private:
};

int main()
{
	AbstractFactory* cf1 = new ConcreteFactory1();
	cf1->CreateClothBoy("ClothBoyB");
	cf1->CreateClothGirl("ClothGirlA");
	AbstractFactory* cf2 = new ConcreteFactory2();
	cf2->CreateClothBoy("ClothBoyA");
	cf2->CreateClothGirl("ClothGirlB");
	return 0;
}