设计模式之工厂模式

/////////////
/*简单工厂模式
		首先定义一个抽象Product类，类中有该产品需要的方法，为抽象基类，子类集成Product，各自实现基类的方法
		其次定一个抽象工厂类AbstractFactory，AbstractFactory中定义创建各个继承Product的子类的方法，然后定义一个工厂继承自并实现AbstractFactory
	中的方法。factory->crateProduct(str)->A ,factory->crateProduct(str)-> B
*/
class Product                              
{
public:
	virtual ~Product();
	virtual void operation() = 0;
};

class ProductA:public Product
{
	~ProductA();
	void operation(){	cout<<"Product A"<<endl;}
};

class ProductB : public Product
{
	~ProductB();
	void operation(){	cout << "Product B"<<endl;}
};

class AbstractFactory
{
	virtual ~AbstractFactory();
	virtual Product* createProductA() = 0;
	virtual Product* createProductB() = 0;
};

class ConcreteFactory : public AbstractFactory
{

	Product* createProductA(){		return new ProductA();}
	Product* createProductB(){		return new ProductB();}
};	

int main
{
	AbstractFactory* factory = new ConcreteFactory();
	Product* productA = factory->createProductA();
	Product* productB = factory->createProductB();
	productA->operation();
	productB->operation();

	delete factory;
	delete productA;
	delete productB;
};

/*工厂模式
		工厂模式中，只是把工厂分为一个抽象工厂和若干个实现的工厂（factoryA，factoryB），每个工厂产出各自对应的产品（A，B）、
		factoryA->crateProduct->A, factoryB->crateProduct->B
*/
class Product
{
public:
	virtual ~Product();
	virtual void operation() = 0;
};
class ProductA: public Product
{
public:
	ProductA();
	void operation(){cout << "product A"<<endl;}
};
class ProductB: public Product
{
public:
	ProductB();
	void operation(){cout << "product B"<<endl;}
};
class AbstractFactory
{
public:
	virtual ~AbstractFactory();
	virtual Product* createProduct()=0;
};
class FactoryA: public AbstractFactory
{
public:
	~FactoryA();
	Product* createProduct(){return new ProductA();}
};
class FactoryB: public AbstractFactory
{
public:
	~FactoryB();
	Product* createProduct(){return new ProductB();}
};
int main()
{
	AbstractFactory* factoryA = new FactoryA();
	AbstractFactory* factoryB = new FactoryA();
	Product* productA = factoryA->createProduct();
	Product* productB = factoryB->createProduct();
	productA->operation();
	productB->operation();

	delete factoryA;
	delete factoryB;
	delete productA;
	delete productB;
}

/*抽象工厂模式
		工厂模式中，只是把工厂分为一个抽象工厂和若干个实现的工厂，每个工厂（factory1，factory2）产出各自的对应的一组产品（A1，B1为一组，A2，B2为一组）
		factory1->createProductA->A1	factory2->createProductA->A2
		factory1->createProductB->B1	factory2->createProductB->B2
*/
class Product
{
public:
	virtual ~Product();
	virtual void operation() = 0;
};
class ProductA1 : public Product
{
public:
	ProductA();
	void operation(){cout << "product A1"<<endl;}
};
class ProductA2 : public Product
{
public:
	ProductA();
	void operation(){cout << "product A2"<<endl;}
};
class ProductB1 : public Product
{
public:
	ProductB1();
	void operation(){cout << "product B1"<<endl;}
};
class ProductB2 : public Product
{
public:
	ProductB2();
	void operation(){cout << "product B2"<<endl;}
};

class AbstractFactory
{
public:
	virtual ~AbstractFactory();
	virtual Product* createProductA() = 0;
	virtual Product* createProductB() = 0;
};
class Factory1 : public AbstractFactory
{
	~Factory1();
	Product* createProductA(){return new ProductA1();}
	Product* createProductB(){return new ProductB1();}
};
class Factory2 : public AbstractFactory
{
	~Factory1();
	Product* createProductA(){return new ProductA2();}
	Product* createProductB(){return new ProductB2();}
};
int main
{
	AbstractFactory factory1 = new Factory1();
	AbstractFactory factory2 = new Factory1();
	Product* productA1 = factory1->createProductA();
	Product* productB1 = factory1->createProductB();
	Product* productA2 = factory1->createProductA();
	Product* productB2 = factory1->createProductB();

	delete factory1;
	delete factory2;
	delete productA1;
	delete productA2;
	delete productB1;
	delete productB2;
};