工厂模式

工厂模式分为3种，即简单工厂模式、工厂方法模式、抽象工厂模式，C++的工厂模式主要利用到虚函数。

简单工厂

简单工厂模式有一个工厂，可以生产多个产品，包含两个接口，一个是产品类的，一个是工厂类的。
产品类需要有一个基类，基类中的具体产品实现需要是个纯虚函数，这样一来，产品的子类必须要重写具体的产品实现，实现不同的功能。
产品类封装完成后，还需要一个工厂类，工厂类对产品类再次封装，最终实现由一个工厂对象决定创建出哪一种产品类的实例。

//衣服的抽象
class Clothes{
public:
	virtual void produce() = 0;
};
//夹克
class Jacket: public Clothes{
public:
	void produce(){cout<< produce a Jacket;}
};
//裙子
class Dress: public Clothes{
public:
	void produce(){cout<< produce a Dress;}
};
//工厂
class Factory{
public:
	Product* Create(int type){
		switch (type){
		case 1:
			return new Jacket;break;
		case 2:
			return new Dress;break;
		default:
			break;
		}
	}
};

int main()
{
	//建造一个工厂
	Factory *factory = new Factory();
	//工厂生产一个夹克
	factory->Create(1)->produce();
	//工厂生产一个裙子
	factory->Create(2)->produce();
	return 0;
}

上面的代码中实现了两个产品，一个夹克一个裙子，选择生产哪一种完全由工厂类封装的Create()来决定。
但是简单工厂模式违背开放-封闭原则，即对扩展开放，对修改封闭。若要添加第三个产品 “裤子” 时，需要修改工厂类的代码。

工厂方法

由于简单工厂模式的弊端，发展出了工厂方法。工厂方法模式有多个工厂，但是每个工厂只对应一个产品。此时工厂类和产品类都有基类，并且都包含一个纯虚函数。

//衣服的抽象
class Clothes{
public:
	virtual int produce() = 0;
};
//夹克
class Jacket: public Clothes{
public:
	void produce(){cout<< produce a Jacket;}
};
//裙子
class Dress: public Clothes{
public:
	void produce(){cout<< produce a Dress;}
};
//工厂的抽象
class Factory{
public:
	virtual Product* Create() = 0;
};
//生产夹克的工厂
class Factory_Jacket: public Factory{
public:
	Product* Create(){return new Jacket;}
};
//生产裙子的工厂
class Factory_Dress: public Factory{
public:
	Product* Create(){return new Dress;}
};

int main()
{
	//建造夹克工厂
	Factory_Jacket *factory_jacket = new Factory_Jacket();
	//建造裙子工厂
	Factory_Dress *factory_dress = new Factory_Dress();
	//夹克工厂生产夹克
	factory_jacket->Create()->produce();
	//裙子工厂生产裙子
	factory_dress->Create()->produce();
	return 0;
}

当增加一个新产品时，同时增加一个新工厂。增加新工厂属于扩展，不会修改以前工厂类和产品类的任何代码。

抽象工厂

在工厂方法的基础上，如果一个工厂想要生产多个产品，就有了抽象工厂模式，抽象工厂模式提供了一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。抽象工厂模式其实是简单工厂模式和工厂方法模式的组合。

//白衣服的抽象
class Clothes_White{
public:
	virtual void produce() = 0;
};
//白夹克
class Jacket_White: public Clothes_White{
public:
	void produce(){cout<< produce a Jacket White;}
};
//白裙子
class Dress_White: public Clothes_White{
public:
	void produce(){cout<< produce a Dress White;}
};
//黑衣服的抽象
class Clothes_Black{
public:
	virtual int produce() = 0;
};
//黑夹克
class Jacket_Black: public Clothes_Black{
public:
	void produce(){cout<< produce a Jacket White;}
};
//黑裙子
class Dress_Black: public Clothes_Black{
public:
	int produce(){cout<< produce a Dress White;}
};
//黑白衣服工厂的抽象
class Factory{
public:
	virtual Clothes_White* Create_Jacket() = 0;
	virtual Clothes_Black* Create_Dress() = 0;
};
//生产白衣服的工厂
class Factory_White : public Factory{
public:
	Jacket_White* Create_Jacket(){return new Jacket_White;}
	Dress_White*  Create_Dress(){return new Dress_White;}
};
//生产黑衣服的工厂
class Factory_Black : public Factory{
public:
	Jacket_Black* Create_Jacket(){return new Jacket_Black;}
	Dress_Black* Create_Dress(){return new Dress_Black;}
};

int main()
{
	//建造白衣服工厂
	Factory_White *factory_white = new Factory_White();
	//建造黑衣服工厂
	Factory_Black *factory_black = new Factory_Black();
	//白衣服工厂生产白夹克
	factory_white ->Create_Jacket()->operation();
	//白衣服工厂生产白裙子
	factory_white ->Create_Dress()->operation();
	//白衣服工厂生产黑夹克
	factory_black ->Create_Jacket()->operation();
	//白衣服工厂生黑裙子
	factory_black ->Create_Dress()->operation();
	return 0;
}