C++工厂模式

工厂模式分为3种，即简单工厂模式、工厂方法模式、抽象工厂模式，C++的工厂模式主要利用到虚函数。

简单工厂模式

简单工厂模式有一个工厂，可以生产多个产品，包含两个接口，一个是产品类的，一个是工厂类的。
产品类需要有一个基类，基类中的具体产品实现需要是个纯虚函数，这样一来，产品的子类必须要重写具体的产品实现，实现不同的功能。
产品类封装完成后，还需要一个工厂类，工厂类对产品类再次封装，最终实现由一个工厂对象决定创建出哪一种产品类的实例。

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

//产品的基类
class Product{
public:
   //基类中的纯虚函数
	virtual int operation(int a, int b) = 0;
};
//产品的子类Add
class Product_Add : public Product{
public:
	int operation(int a, int b){
		return a + b;
	}
};
//产品的子类Mul
class Product_Mul : public Product{
public:
	int operation(int a, int b){
		return a * b;
	}
};
//工厂
class Factory{
public:
	Product* Create(int i){
		switch (i){
		case 1:
			return new Product_Add;
			break;
		case 2:
			return new Product_Mul;
			break;
		default:
			break;
		}
	}
};

int main()
{
	Factory *factory = new Factory();
	int add_result = factory->Create(1)->operation(1, 2);
	int mul_result = factory->Create(2)->operation(1, 2);
	cout <<"op_add：" <<add_result << endl;
	cout <<"op_multiply：" << mul_result << endl;
		getchar();
	return 0;
}

上面的代码中实现了两个产品，一个“加”，一个“乘”，选择哪一种操作完全由工厂类封装的Create()来决定。
但是简单工厂模式违背开放-封闭原则，即对扩展开放，对修改封闭。因为要添加第三个产品“减”时，需要修改工厂类的代码。

工厂方法模式

由于简单工厂模式的弊端，发展出了工厂方法模式。工厂方法模式有多个工厂，但是每个工厂只对应一个产品。此时工厂类和产品类都有基类，并且都包含一个纯虚函数。

#include<iostream>

using namespace std;

//工厂方法模式
class Product{
public:
	virtual int operation(int a, int b) = 0;
};

class Product_Add : public Product{
public:
	int operation(int a, int b){
		return a + b;
	}
};

class Product_Mul : public Product{
public:
	int operation(int a, int b){
		return a * b;
	}
};

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


class Factory_Add : public Factory{
public:
	Product* Create(){
		return new Product_Add;
	}
};

class Factory_Mul : public Factory{
public:
	Product* Create(){
		return new Product_Mul;
	}
};

int main()
{
	Factory_Add *factory_add = new Factory_Add();
	Factory_Mul *factory_mul = new Factory_Mul();
	int add_result = factory_add->Create()->operation(1, 2);
	int mul_result = factory_mul->Create()->operation(1, 2);
	cout << "op_add：" << add_result << endl;
	cout << "op_multiply：" << mul_result << endl;
	getchar();
	return 0;
}

当增加一个新产品时，同时增加一个新工厂。增加新工厂属于扩展，不会修改以前工厂类和产品类的任何代码。

抽象工厂模式

在工厂方法模式的基础上，如果一个工厂想要生产多个产品，就有了抽象工厂模式，抽象工厂模式提供了一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。抽象工厂模式其实是简单工厂模式和工厂方法模式的组合。

#include<iostream>
using namespace std;

//抽象工厂模式
class Product_P{
public:
	virtual int operation(int a, int b) = 0;
};

class Product_Padd : public Product_P{
public:
	int operation(int a, int b){
		return abs(a) + abs(b);
	}
};

class Product_Pmul : public Product_P{
public:
	int operation(int a, int b){
		return abs(a) * abs(b);
		
	}
};

class Product_F{
public:
	virtual int operation(int a, int b) = 0;
};

class Product_Fadd : public Product_F{
public:
	int operation(int a, int b){
		return (-a) + (-b);
	}
};
class Product_Fmul : public Product_F{
public:
	int operation(int a, int b){
		return -(a*b);
	}
};

class Factory{
public:
	virtual Product_P* Create_P() = 0;
	virtual Product_F* Create_F() = 0;
};


class Factory_Add : public Factory{
public:
	  Product_Padd* Create_P(){
		return new Product_Padd;
	}
	Product_Fadd*  Create_F(){
		return new Product_Fadd;
	}
};

class Factory_Mul : public Factory{
public:
	Product_Pmul* Create_P(){
		return new Product_Pmul;
	}
	Product_Fmul* Create_F(){
		return new Product_Fmul;
	}
};

int main()
{
	Factory_Add *factory_add = new Factory_Add();
	Factory_Mul *factory_mul = new Factory_Mul();
	int p_add_result = factory_add->Create_P()->operation(1, 2);
	int p_mul_result = factory_mul->Create_P()->operation(1, 2);
	int f_add_result = factory_add->Create_F()->operation(1, 2);
	int f_mul_result = factory_mul->Create_F()->operation(1, 2);
	cout << "op_p_add：" << p_add_result << endl;
	cout << "op_p_multiply：" << p_mul_result << endl;
	cout << "op_f_add：" << f_add_result << endl;
	cout << "op_f_multiply：" << f_mul_result << endl;
	getchar();
	return 0;
}