C++ 工厂模式

---

上节回顾

在上一章我们讲到了简单工厂模式，在简单工厂模式中，我们可以传入参数决定需要的对象类型，根据客户端选择实例化相关的类，对客户来说除去了产品的依赖，不用关心具体的对象是怎么实例化的，但同时缺点也存在，当我们想增加新的商品时候，不得不修改工厂类，在工厂类中增加对象的实例方法，违背了开放封闭原则。由此诞生了工厂模式。

---

一、工厂模式介绍

工厂模式定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使类的实例化延迟到其子类。

二、场景分析

在（一）中我们已经介绍了，当我们想要增加新的商品时候，我们可以使用工厂模式，在这里我们定义工厂抽象类，在工厂抽象类中定义实例化方法定义，然后在工厂子类中实现实例化创建方法，UML如下：

三、代码展示

抽象类代码：

namespace Goods
{
	// 抽象类
	class AbstractGoods
	{
	public:
		// 得到商品价格
		virtual double GetSpice() = 0;
	private:
		double spice;
	};
}
namespace Factory
{
	//抽象工厂方法
	class AbstractFactory
	{
	public:
		// 定义实例化对象接口
		virtual Goods::AbstractGoods * Create() = 0;
	};
}

产品实现代码：

// 具体实现 香蕉
class BananaGoods : public AbstractGoods
{
public:
	virtual double GetSpice();
};

//具体实现 苹果
class AppleGoods : public AbstractGoods
{
public:
	virtual double GetSpice();
};

class PingPongGoods : public AbstractGoods
{
public:
	virtual double GetSpice();
};
double Goods::BananaGoods::GetSpice()
{
	return 3.5;
}

double Goods::AppleGoods::GetSpice()
{
	return 5.5;
}

double Goods::PingPongGoods::GetSpice()
{
	return 1.0;
}

工厂实现方法：

class BananaFactory : public AbstractFactory
{
public:
	virtual AbstractGoods *Create();
};
class AppleFactory : public AbstractFactory
{
public:
	virtual AbstractGoods *Create();
};
class PingPongFactory : public AbstractFactory
{
public:
	virtual AbstractGoods *Create();
};
AbstractGoods * Factory::BananaFactory::Create()
{
	return new BananaGoods();
}

AbstractGoods * Factory::AppleFactory::Create()
{
	return new AppleGoods();
}

AbstractGoods * Factory::PingPongFactory::Create()
{
	return new PingPongGoods();
}

客户端调用代码

BananaFactory * Fbanana = new BananaFactory();
AbstractGoods *banana = Fbanana->Create();

AppleFactory * Fapple = new AppleFactory();
AbstractGoods *apple = Fapple->Create();

PingPongFactory * Fpingpong = new PingPongFactory();
AbstractGoods *pingpong = Fpingpong->Create();
cout << "banana		spice = " << banana->GetSpice() << endl;
cout << "apple		spice = " << apple->GetSpice() << endl;
cout << "pingpong	spice = " << pingpong->GetSpice() << endl;

delete Fpingpong; 
Fpingpong = nullptr;
delete pingpong; 
pingpong = nullptr;
delete Fapple; 
Fapple = nullptr;
delete apple; 
apple = nullptr;
delete Fbanana; 
Fbanana = nullptr;
delete banana; 
banana = nullptr;

四、优缺点

优点

1、相对比简单工厂来说，加入了开闭原则，提高高内聚和松耦合。
2、基类为工厂，子类重新新的实现
3、调用者不用关心如何实例化对象的

缺点

每当增加一个实例时候，就需要增加一个工厂方法。