[C++] 设计模式-几种工厂模式

Factory

• 工厂模式
• 简单工厂模式
• 工厂方法模式
• 抽象工厂模式

工厂模式

严格来说，简单工厂模式不属于GOF设计模式范围内，这里拿来用作比较学习。

简单工厂模式

简言之，简单工厂指的是，有一个工厂，可以生产不同的产品，产品有一个抽象类，不同的实际产品类实现抽象类。代码如下：

#include <iostream>
using namespace std;

// Simple Factory
class Car
{
public:
	virtual void show() = 0;
};

class Benz : public Car
{
public:
	void show()
	{
		cout << "Benz" << endl;
	}
};

class Bmw : public Car
{
public:
	void show()
	{
		cout << "Bmw" << endl;
	}
};

class Factory
{
public:
	enum CarBrand
	{
		BENZ,
		BMW
	};

	Car* CreateCar(CarBrand type)
	{
		Car* temp = nullptr;
		switch (type)
		{
		case Factory::BENZ:
			temp = new Benz();
			break;
		case Factory::BMW:
			temp = new Bmw();
			break;
		default:
			temp = nullptr;
			break;
		}
		return temp;
	}
};

int main()
{
	Factory* factory = new Factory();
	factory->CreateCar(Factory::BENZ)->show();
	factory->CreateCar(Factory::BMW)->show();
}

定义了抽象类Car，Benz与Bmw分别继承实现了Car。在工厂类Factory内，提供生成两个类的实例对象的方法，通过条件判断生成不同的实例。运行结果：

Benz
Bmw

工厂方法模式

与简单工厂模式相比较，工厂方法模式有两个工厂，每个工厂分别生产各自的产品。所以产品有一个抽象类，工厂也有一个抽象类。

// Factory Method
class Car
{
public:
	virtual void show() = 0;
};

class Benz : public Car
{
public:
	void show()
	{
		cout << "Benz" << endl;
	}
};

class Bmw : public Car
{
public:
	void show()
	{
		cout << "Bmw" << endl;
	}
};

class Factory
{
public:
	virtual Car* create() = 0;
};

class Factory_A : public Factory
{
public:
	Car* create()
	{
		return new Benz();
	}
};

class Factory_B : public Factory
{
public:
	Car* create()
	{
		return new Bmw();
	}
};

int main()
{
	Factory* factory_A = new Factory_A();
	factory_A->create()->show();

	Factory* factory_B = new Factory_B();
	factory_B->create()->show();
}

Factory_A工厂只生产Benz，而Factory_B只生产Bmw。结果：

Benz
Bmw

抽象工厂模式

抽象工厂模式相对于前两种，有两个工厂，有两个产品，两个产品还有不同的型号，如Benz有E级与S级，Bmw有5系与7系。两个工厂分别为Benz的工厂，Bmw的工厂。

// Abstract Factory Pattern
class CClass // C级车
{
public:
	virtual void show() = 0;
};

class BenzESeries : public CClass // 奔驰E级
{
public:
	void show()
	{
		cout << "Benz E Class" << endl;
	}
};

class Bmw5Series : public CClass // 宝马5系
{
public:
	void show()
	{
		cout << "Bmw 5 Series" << endl;
	}
};

class DClass // D 级车
{
public:
	virtual void show() = 0;
};

class BenzSSeries : public DClass // 奔驰S级
{
public:
	void show()
	{
		cout << "Benz S Series" << endl;
	}
};

class Bmw7Series : public DClass // 宝马7系
{
public:
	void show()
	{
		cout << "Bmw 7 Series" << endl;
	}
};

class Factory
{
public:
	virtual CClass* createCClass() = 0;
	virtual DClass* createDClass() = 0;
};

class Factory_Benz : public Factory // 奔驰的工厂，可以生产E级与S级
{
public:
	CClass* createCClass()
	{
		return new BenzESeries();
	}

	DClass* createDClass()
	{
		return new BenzSSeries();
	}
};

class Factory_Bmw : public Factory // 宝马的工厂可以生产5系与7系
{
public:
	CClass* createCClass()
	{
		return new Bmw5Series();
	}

	DClass* createDClass()
	{
		return new Bmw7Series();
	}
};

int main()
{
	Factory* Benz = new Factory_Benz();
	Benz->createCClass()->show();
	Benz->createDClass()->show();

	Factory* Bmw = new Factory_Bmw();
	Bmw->createCClass()->show();
	Bmw->createDClass()->show();
}

结果：

Benz E Class
Benz S Series
Bmw 5 Series
Bmw 7 Series

本文代码参考了C++工厂模式总结，设计模式之抽象工厂模式（C++）。

来源：https://blog.csdn.net/weixin_42852335/article/details/100120128