Factory：工厂模式

      工厂模式有3种。以下的示例代码都省略了构造函数与析构函数。

一．     简单工厂模式

简单工厂模式就是只有一个工厂，所有的产品都有该工厂生产。每一种产品都有一个对应的type。当需要某种产品时，将该产品的type传给工厂，然后工厂即会返回该产品。

这样意味着工厂内部必须针对type作判断，也就是使用一个switch语句来根据传入的type，决定创建哪一种产品。

当产品种类很多时，这个switch会非常庞大。

1.    定义产品

class AbstractProduct
{
public:
	virtual void operation() = 0;
};

class ProductA :public AbstractProduct
{
public:
	void operation();
};

class ProductB :public AbstractProduct
{
public:
	void operation();
};

2.    定义工厂

class AbstractFactory
{
public:
	virtual AbstractProduct* createProduct(int type) = 0;
};

class SimpleFactory :public AbstractFactory
{
public:
	AbstractProduct* createProduct(int type);
};

AbstractProduct* SimpleFactory::createProduct(int type)
{
	AbstractProduct* temp = NULL;
	switch (type)
	{
	case 1:
		temp = new ProductA();
		break;
	case 2:
		temp = new ProductB();
		break;
	default:
		break;
	}
	return temp;
}

3.    使用工厂

void main()
{
	AbstractFactory* factory = new SimpleFactory();
	AbstractProduct* product = nullptr;

	product = factory->createProduct(1);
	product->operation();
	delete product;

	product = factory->createProduct(2);
	product->operation();
	delete product;
}

二．     工厂方法模式

工厂方法模式会定义一个抽象工厂，该抽象工厂规定了产生产品的接口。

然后由抽象工厂，针对于每一种产品，单独派生对应的工厂。这样，每一种产品都有自己专门的工厂进行生产。即产品与工厂一一对应。

当要生产某种产品时，需要调用对应工厂的生产函数。

这样，意味着当产品种类非常多的时候，工厂也会非常多。

1.    定义产品

class AbstractProduct
{
public:
	virtual void operation() = 0;
};

class ProductA :public AbstractProduct
{
public:
	void operation();
};

class ProductB :public AbstractProduct
{
public:
	void operation();
};

2.    定义工厂

class AbstractFactory
{
public:
	virtual AbstractProduct* createProduct() = 0;
};

class FactoryA :public AbstractFactory
{
public:
	AbstractProduct* createProduct();
};

class FactoryB :public AbstractFactory
{
public:
	AbstractProduct* createProduct();
};

AbstractProduct* FactoryA::createProduct()
{
	AbstractProduct* temp = NULL;
	temp = new ProductA();
	return temp;
}

AbstractProduct* FactoryB::createProduct()
{
	AbstractProduct* temp = NULL;
	temp = new ProductB();
	return temp;
}

3.    使用工厂

void main()
{
	AbstractFactory* factory = nullptr;
	AbstractProduct* product = nullptr;

	factory = new FactoryA();
	product = factory->createProduct();
	product->operation();
	delete product;
	delete factory;

	factory = new FactoryB();
	product = factory->createProduct();
	product->operation();
	delete product;
	delete factory;
}

三．     抽象工厂模式

抽象工厂模式折中了简单工厂模式与抽象工厂模式。

抽象工厂模式的产品是分类的，某一类产品有多种，那么针对于这一类产品，构造一个工厂。这个工厂可以生产这一类产品中的任何一种。

一般来说，这类工厂用于产品适配的情况。如windows下需要生产一个窗口，linux下也需要生产一个窗口，那么就可以创建两个工厂，分别负责不同平台下窗口的产生。但是这样也意味着，若添加一种产品，则每个工厂都要针对该产品进行修改。

1.    定义产品

class AbstractProductA
{
public:
	virtual void operationA() = 0;
};

class ProductA_1 :public AbstractProductA
{
public:
	void operationA();
};

class ProductA_2 :public AbstractProductA
{
public:
	void operationA();
};


class AbstractProductB
{
public:
	virtual void operationB() = 0;
};

class ProductB_1 :public AbstractProductB
{
public:
	void operationB();
};

class ProductB_2 :public AbstractProductB
{
public:
	void operationB();
};

2.    定义工厂

class AbstractFactory
{
public:
	virtual AbstractProductA* createProductA() = 0;
	virtual AbstractProductB* createProductB() = 0;
};

class Factory1 :public AbstractFactory
{
public:
	AbstractProductA* createProductA();
	AbstractProductB* createProductB();
};

class Factory2 :public AbstractFactory
{
public:
	AbstractProductA* createProductA();
	AbstractProductB* createProductB();
};

AbstractProductA* Factory1::createProductA()
{
	AbstractProductA* temp = NULL;
	temp = new ProductA_1();
	return temp;
}

AbstractProductB* Factory1::createProductB()
{
	AbstractProductB* temp = NULL;
	temp = new ProductB_1();
	return temp;
}

AbstractProductA* Factory2::createProductA()
{
	AbstractProductA* temp = NULL;
	temp = new ProductA_2();
	return temp;
}

AbstractProductB* Factory2::createProductB()
{
	AbstractProductB* temp = NULL;
	temp = new ProductB_2();
	return temp;
}

3.    使用工厂

void main()
{
	AbstractFactory* factory = nullptr;

	factory = new Factory1();
	AbstractProductA* productA = factory->createProductA();
	AbstractProductB* productB = factory->createProductB();
	productA->operationA();
	productB->operationB();

	delete factory;
	delete productA;
	delete productB;

	factory = new Factory2();
	productA = factory->createProductA();
	productB = factory->createProductB();
	productA->operationA();
	productB->operationB();

	delete factory;
	delete productA;
	delete productB;
}