c++设计模式之简单工厂模式，抽象工厂模式

简单工厂模式：

主要特点是需要在工厂中做判断，从而创造相应的产品，当增加新产品时，需要修改工厂类。

简单工厂模式是工厂模式中最简单的一种。该模式隐藏了实例化对象的过程，只需要用户输入实例化对象的名字，就可以通过对象工厂对应的工厂函数来制造需要的对象。

每个子类对象继承自一个虚基类，工厂通过传来的需要实例化的子类对象，new一个基类的指针，指针指向基类的虚函数，从而动态绑定子类的重写函数，实现多态，生产不同的产品。

代码：

#include<iostream>
using namespace std;
//*简单工厂模式/**/

/*创建一个基类*/
class Base
{
public:
	int a;
	int b;
	virtual double Result()
	{
		return 0;
	}
};

/*产品a类*/
class A:public Base
{
public:
	virtual double Result()
	{
		return a + b;
	}
};

/*产品B类*/
class B:public Base
{
	virtual double Result()
	{
		return a - b;
	}
};

/*工厂类*/
class Factory
{
public:
	
	static Base * Create(char ch)
	{	Base *p;
		switch (ch)
		{
		case 'a':p = new A(); break;
		case 'b':p = new B(); break;
		default:p = new A(); break;
		}
		return p;
	}
};

int main()
{
	int fa = 10;
	int fb = 5;
	Base *p = Factory::Create('b');
	p->a = fa;
	p->b = fb;
	//p = Factory::Create('a');
	cout << p->Result() << endl;
	delete p;
	return 0;
}

（2）抽象工厂模式

简单工厂模式要求产品子类必须要是同一类型的，拥有共同的方法，这就限制了产品子类的扩展。于是为了更加方便的扩展，抽象工厂模式就将同一类的产品子类归为一类，让他们继承同一个抽象子类，我们可以把他们一起视作一组，然后好几组产品构成一族。

此时，客户端要使用时必须知道是哪一个工厂并且是哪一组的产品抽象类。每一个工厂子类负责产生一族产品，而子类的一种方法产生一种类型的产品

代码：

#include<iostream>
using namespace std;

class productA//A产品
{
public:
	virtual void product(){}
	
};
class A1 :public productA
{
public:
	void product()
	{
		cout << "product A1++" << endl;
	}
};
class A2 :public productA
{
public:
	void product()
	{
		cout << "product A2++" << endl;
	}
};

class productB//B产品
{
public:
	virtual void product(){}
};
class B1 :public productB
{
public:
	void product()
	{
		cout << "product B1++" << endl;
	}
};
class B2 :public productB
{
public:
	void product()
	{
		cout << "product B2++" << endl;
	}
};

class factory
{
public:
	virtual productA * creatA() = 0;
	virtual productB * creatB() = 0;
};

class factoryA :public factory
{
public:
	productA *creatA()
	{
		productA *tmp = NULL;
		tmp = new A1();
		return tmp;
	}
	productB *creatB()
	{
		productB *tmp = NULL;
		tmp = new B1();
		return tmp;
	}
};
class factoryB :public factory
{
public:
	productA *creatA()
	{
		productA *tmp = NULL;
		tmp = new A2();
		return tmp;
	}
	productB *creatB()
	{
		productB *tmp = NULL;
		tmp = new B2();
		return tmp;
	}
};
int main()
{
	factoryA *pa = new factoryA();
	productA *p1=pa->creatA();
	p1->product();
	productB *p2=pa->creatB();
	p2->product();
	delete pa;
	delete p1;
	delete p2;
	return 0;
}