C++设计模式——工厂模式（Factory 模式）

工厂模式

什么是工厂模式？

• 工厂模式是一种创造型的模式
• 通过绕开new的方法去创建对象，避免创建对象(new)过程中所导致的紧耦合,使得具体化类的工作延迟到了子类中
• 定义创建对象的接口，封装了对象的创建

GOF定义的UML图

Factory(抽象类)：提供创建对象共同的接口，提供派生类继承
ConcreteFactoty(具体工厂)：继承于Factory，负责创造具体的产品
Product(抽象产品类)：产品的抽象类，具有产品共同的接口
ConcreteProduct(具体产品类)：具体的产品

可能看这个概念不太好理解，举一个具体例子

现在有一个人的抽象类，提供了一个eat()吃的公共接口，它的子类有白种人、黄种人，分别重写了eat()的方法。

man.h

#ifndef _MAN_H
#define _MAN_H
#include <iostream>
using namespace std;

//人(抽象)
class Man
{
public:
	virtual ~Man(){};
	virtual void Eat() = 0;

protected:
	Man(){};
};

//黄种人（具体）
class YellowMan :public Man
{
public:
	YellowMan(){};
	~YellowMan(){};
	void Eat()
	{
		cout << "I am YellowMan" << endl;
	}

};

//白人（具体）
class WhiteMan :public Man
{
public:
	WhiteMan(){};
	~WhiteMan(){};
	void Eat()
	{
		cout << "I am WhiteMan" << endl;
	}

};

#endif

不使用工厂模式时

有MyClass的一个类，有一个MyFun()的方法，在方法里面具体的调用了new，创建一个黄种人并使用eat()这个方法。

class MyClass
{
public:
	MyClass(){};
	~MyClass(){};

	void MyFun();

private:
	YellowMan* yellowMan
};

void MyClass::MyFun()
{
	YellowMan* yellowMan = new YellowMan();
	yellowMan->Eat();
}

假设，我现在有业务需求，需要添加一个黑种人，并在该类中使用eat()的方法，那么该怎么办?将new YellowMan()改成 new BlackMan()?那就违法了开闭原则：对拓展开放，对修改关闭。

此时工厂模式就可以解决该类的问题。

使用工厂模式

1.创建一个抽象类的工厂基类提供创建对象的接口
2.添加具体工厂类，负责创建对象

#ifndef _FACTORY_H_ 
#define _FACTORY_H_
#include "Man.h"
using namespace std;

//人类（抽象）
class Man;

//抽象类工厂
class ManFactory
{
public:
	virtual ~ManFactory(){};
	virtual Man* CreateMan() = 0;

protected:
	ManFactory(){};

};


//黄种人工厂(具体工厂)
class YellowManFactory :public ManFactory
{
public:
	YellowManFactory(){};
	~YellowManFactory(){};
	Man* CreateMan()
	{
		return new YellowMan();
	};
};

//白人工厂(具体工厂)
class WhiteManFactory :public ManFactory
{
public:
	WhiteManFactory(){};
	~WhiteManFactory(){};
	Man* CreateMan()
	{
		return new WhiteMan();
	};
};

#endif

此时再对MyClass稍作修改
1.在类内添加一个ManFactory（抽象类）的对象
2.通过构造函数将具体的工厂传入类内
3.MyFun里面，只需要调用ManFactory的接口来创建对象(没有暴露具体创建对象的细节new)

class MyClass
{
public:
	MyClass(ManFactory* Factory) {
		this->manFactory = Factory;
	};
	~MyClass(){};

	void MyFun();

private:
	ManFactory* manFactory;
	Man* man;
};

void MyClass::MyFun()
{
	man = manFactory->CreateMan();
	man->Eat();
}

int main()
{
	//黄种人
	YellowManFactory* yellowManFactory = new YellowManFactory();
	MyClass myClass1(yellowManFactory);
	myClass1.MyFun();

	//白种人
	WhiteManFactory* whiteManFactory = new WhiteManFactory();
	MyClass myClass2(whiteManFactory);
	myClass2.MyFun();

	while (true);
	return 0;

}

运行的结果

那么当我们需要调用黑人的eat()的方法时，只需要添加一个黑人类和黑人工厂(拓展)，将具体工厂传入到Myclass类，就可以实现对应的需求，达到Myclass()类的复用。

这个时候再理解工厂模式的特点就会很好理解

• 通过绕开new的方法去创建对象，避免创建对象(new)过程中所导致的紧耦合,使得具体化类的工作延迟到了子类中

工厂模式缺点

• 每增加一个产品，相应的也要增加一个子工厂，加大了额外的开发量。

注：要注意在实际项目中创建对象的内存释放工作，案例中没有具体去写析构函数的实现