C++设计模式：工厂模式(简单工厂模式，工厂方法模式，抽象工厂模式)

设计模式：工厂模式

工厂模式：是一种创建型模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
工厂模式分为三种：

• 简单工厂模式
• 工厂方法模式
• 抽象工厂模式

---

简单工厂模式：
一个工厂，通过switch语句来提供不同类型的对象的创建。试用于规模固定，不容易发生产品变动。
缺点：不满足开放-封闭原则，当出现新产品的时候，需要在switch里加case语句
开放-封闭原则

• 开放原则：新版本设计时可以使用旧版本的代码
• 封闭原则：不能修改修版本的代码

class Fruit
{
public:
	Fruit(string name) :mname(name){}
	virtual void operation() = 0;//怎么吃
protected:
	string mname;
};
class Apple :public Fruit
{
public:
	Apple(string name) :Fruit(name){};
	void operation()
	{
		cout << "this is an apple" << endl;
	}
};
class Banana :public Fruit
{
public:
	Banana(string name) :Fruit(name){};
	void operation()
	{
		cout << "this is an banana" << endl;
	}
};
class Factory{
public:
	Fruit*createFruit(int flag)
	{
		switch (flag)
		{
		case 1:
			return new Apple("apple");
			break;
		case 2:
			return new Banana("banana");
			break;
		default:
			return NULL;
			break;
		}
	}
};
int main()
{
	Factory fr;
	Fruit*pf = fr.createFruit(1);
	pf->operation();
	return 0;
}

---

工厂方法模式：
多个工厂，每个工厂生产对应的产品（提供不同类型的对象的创建）。当有新产品的时候，只需要新增产品类和工厂类就可以了。

class Fruit
{
public:
	Fruit(string name) :mname(name){}
	virtual void operation() = 0;//怎么吃
protected:
	string mname;
};
class Apple :public Fruit
{
public:
	Apple(string name) :Fruit(name){};
	void operation()
	{
		cout << "this is an apple" << endl;
	}
};
class Banana :public Fruit
{
public:
	Banana(string name) :Fruit(name){};
	void operation()
	{
		cout << "this is an banana" << endl;
	}
};
class Factory{
public:
	Factory(string name) :mname(name){}
	virtual Fruit*createFruit() =0;
protected:
	string mname;
};
class F1:public Factory
{
public:
	F1(string name) :Factory(name){}
	virtual Fruit*createFruit()
	{
		return new Apple("apple");
	}
};
class F2:public Factory
{
public:
	F2(string name) :Factory(name){}
	virtual Fruit*createFruit()
	{
		return new Banana("banana");
	}
};
int main()
{
	Factory* pfa = new F1("f1");
	Fruit *pf=pfa->createFruit();
	pf->operation();
	return 0;
}

---

抽象工厂模式：
多系列产品，多系列工厂，通过工厂需要不同系列的产品而调用多个类的构造。

给个例子：

A类负责屏幕的生产：13.5寸的屏幕和15.6寸的屏幕
B类负责外壳的生产：13.5寸的外壳和15.6寸的外壳
工厂1负责13.5寸电脑的生产
工厂2负责15.6寸电脑的生产

class A
{
public:
	A(string name) :mname(name){}
	virtual void operation() = 0;
protected:
	string mname;
};
class A1 :public A
{
public: 
	A1(string name) :A(name){}
	void operation()
	{
		cout << "a1" << endl;
	}
};
class A2 :public A
{
public: 
	A2(string name) :A(name){}
	void operation()	{
		cout << "a2" << endl;
	}
};
class B
{
public:
	B(string name) :mname(name){}
	virtual void operation() = 0;
protected:
	string mname;
};
class B1 :public B
{
public: 
	B1(string name) :B(name){}
	void operation()
	{
		cout << "b1" << endl;
	}
};
class B2 :public B
{
public: 
	B2(string name) :B(name){}
	void operation()
	{
		cout << "b2" << endl;
	}
};
class ABstractFactory
{
public:
	ABstractFactory(string name) :mname(name){}
	virtual A* createA() = 0;
	virtual B* createB() = 0;
protected:
	string mname;
};
class Factory_1 :public ABstractFactory
{
public:
	Factory_1(string name) :ABstractFactory(name){}
	virtual A* createA()
	{
		return new A1("a1");
	}
	virtual B* createB()
	{
		return new B1("b1");
	}
};
class Factory_2 :public ABstractFactory
{
public:
	Factory_2(string name) :ABstractFactory(name){}
	virtual A* createA()
	{
		return new A2("a2");
	}
	virtual B* createB()
	{
		return new B2("b2");
	}
};
int main()
{
	ABstractFactory *paf =new  Factory_1("f1");
	A*pa = paf->createA();
	B*pb = paf->createB();
	pa->operation();
	pb->operation();
	return 0;
}