三种工厂模式(Factory)

一、简单工厂模式

简单工厂模式事属于创建型模式，又叫做静态工厂方法(static Factory Method)模式，简单工厂模式是由一个工厂对象决定创建出来哪一种产品类的实例，简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一类产品类(这些产品类继承自一个父类或接口)的实例，假设有一个工厂，他能生产出A、B俩种产品，当客户需要产品的时候一定要告诉工厂是哪种产品，是A还是B，当新增加一种新产品的时候那么就要去修改工厂的类

#include "stdafx.h"
#include <iostream>
using namespace std;

typedef enum ProductTypeTag
{
	TypeA,
	TypeB
}PRODUCTTYPE;

class Product
{
public:
	virtual void show() = 0;
};

class Product_A :public Product
{
public:
	virtual void show() { cout << "Product_A" << endl; }
};

class Product_B : public Product
{
public:
	virtual void show() { cout << "Product_B" << endl; }
};

class Factory
{
public:
	Product* Create(PRODUCTTYPE type)
	{
		switch (type)
		{
		case TypeA:
			return new Product_A();
		case TypeB:
			return new Product_B();
		default:
			return NULL;
		}
	}
};

int main()
{
	Factory* factory = new Factory();
	factory->Create(TypeA)->show();
	factory->Create(TypeB)->show();
	return 0;
}

二、工厂方法模式

上面的简单工厂模式的缺点是当新增产品的时候就要去修改工厂的类，这就违反了开放封闭原则，类、模块、函数可以扩展，但是不可以修改，于是就出现了工厂方法模式，所谓工厂方法模式，是指定义一个用于创建对象的接口，让子类决定实例化哪一个类现在有A、B俩种产品，那么就开俩个工厂，工厂A负责生产A产品，工厂B负责生产B产品，这时候客户不需要告诉工厂生产哪种产品了，只需要告诉工厂生产就可以了

#include "stdafx.h"
#include <iostream>
using namespace std;

class Product
{
public:
	virtual void show() = 0;
};

class Product_A :public Product
{
public:
	virtual void show() { cout << "Product_A" << endl; }
};

class Product_B :public Product
{
public:
	virtual void show() { cout << "Product_B" << endl; }
};

class Factory
{
public:
	virtual Product* Create() = 0;
};

class Factory_A :public Factory
{
public:
	virtual Product* Create() { return new Product_A(); }
};

class Factory_B :public Factory
{
public:
	virtual Product* Create() { return new Product_B(); }
};

int main()
{
	Factory_A* productA = new Factory_A;
	Factory_B* productB = new Factory_B;

	productA->Create()->show();
	productB->Create()->show();
	return 0;
}

 

三、抽象工厂模式

假如我们A产品中有A1和A2俩种型号的产品，B产品中有B1和B2俩种型号的产品，上面俩种工厂模式就不能解决了，这就需要抽象工厂模式了，还是开设俩家工厂，工厂1负责生产A1，B1型号产品，2工厂负责生产A2，B2型号的产品

#include "stdafx.h"
#include <iostream>
using namespace std;

//定义抽象类
class ProductA
{
public:
	virtual void show() = 0;
};

//定义具体类
class Product_A1 :public ProductA
{
public:
	virtual void show() { cout << "Product_A1" << endl; }
};

class Product_A2 :public ProductA
{
public:
	virtual void show() { cout << "Product_A2" << endl; }
};

//定义抽象类
class ProductB
{
public:
	virtual void show() = 0;
};

//定义具体类
class Product_B1 :public ProductB
{
public:
	virtual void show() { cout << "Product_B1" << endl; }
};

class Product_B2 :public ProductB
{
public:
	virtual void show() { cout << "Product_B2" << endl; }
};

//定义抽象类
class Factory
{
public:
	virtual ProductA* CreateProductA() = 0;
	virtual ProductB* CreateProductB() = 0;
};

//定义具体类
class Factory1:public Factory
{
public:
	virtual ProductA* CreateProductA() { return new Product_A1(); }
	virtual ProductB* CreateProductB() { return new Product_B1(); }
};

class Factory2 :public Factory
{
public:
	virtual ProductA* CreateProductA() { return new Product_A2(); }
	virtual ProductB* CreateProductB() { return new Product_B2(); }
};

int main()
{
	Factory* factory1 = new Factory1();
	ProductA* productA1 = factory1->CreateProductA();
	ProductB* productB1 = factory1->CreateProductB();
	productA1->show();
	productB1->show();

	Factory* factory2 = new Factory2();
	ProductA* productA2 = factory2->CreateProductA();
	ProductB* productB2 = factory2->CreateProductB();
	productA2->show();
	productB2->show();
}