《二十三种设计模式》 第五篇 “工厂模式” （C++实现）

工厂模式是二十三中设计模式中最常用的一种模式之一，几乎所有开源的框架都有用到工厂模式。

工厂模式可以分为三种：简单工厂模式、工厂方法模式、抽象工厂模式。

其中，简单工厂模式并没有列入到二十三中设计模式中，应为其太简单了，而且违反了开闭原则。

工厂方法模式 与 抽象工厂模式都是简单工厂模式的延伸。

对于工厂模式，其最主要的作用就是定义对象返回！
就是另外再定义类来定义需要使用到的对象，而不再是在main函数中定义对象。
通俗的讲就是分配对象返回（工厂模式就是用来生产对象的）。

---

简单工厂模式

简单工厂模式是三个工厂模式中最简单的，其生产可以集中到一个了类中进行分配对象，进行有效的管理。

举一个例子：
现在市面上有许多品牌的手机，假设小米、华为、苹果三个品牌的手机都是在同一个工厂里生产的，且都是同一时间进行生产，那么工厂就可以决定生产哪个品牌的手机了（想生产哪个品牌的手机就生产哪个品牌的手机），这样就是使用到了简单工厂模式的原理。

可以使用在任何需要new对象的项目中！

UNL类图：

小米、华为、苹果三个类都是继承自手机类，然后手机生产工厂类的实现又依赖于他们三个品牌手机类。

如果还是不懂的话，看下面代码你就会明白他是怎么使用的了。

下面看代码吧：

#include <iostream>
#include <Windows.h>

using namespace std;

// 三台手机的类型
enum PHONE_TYPE {
	MIUI,
	HUAWEI,
	IPHONE
};

// 手机类
class MobilePhone {
public:
	virtual void description() = 0;		// 纯虚函数
};

// 小米手机类
class Miui : public MobilePhone {
public:
	void description() {				// 描述信息
		cout << "小米手机" << endl;
	}
};

// 华为手机类
class Huawei : public MobilePhone {
public:
	void description() {
		cout << "华为手机" << endl;
	}
};

// 苹果手机类
class Iphone : public MobilePhone {
public:
	void description() {
		cout << "苹果手机" << endl;
	}
};


// 手机生产工厂
class Factory {
public:

	// 根据传入来的类型，进行对应的分配对象返回
	MobilePhone *manufacturePhone(PHONE_TYPE type) {
		switch (type) {
			case MIUI:
				return (new Miui());	// 生产小米手机（生成小米手机对象返回）
				break;
			case HUAWEI:
				return (new Huawei());	// 生产华为手机（生成华为手机对象返回）
				break;
			case IPHONE:
				return (new Iphone());	// 生产苹果手机（生成苹果手机对象返回）
				break;
			default:
				return NULL;			// 返回NULL
				break;
		}
	}
};



int main(void) {
	// 建立工厂对象
	Factory *factory = new Factory;

	// 工厂对象调用manufacturePhone方法给父类指针对象分配对象
	MobilePhone *xiaoMi = factory->manufacturePhone(MIUI);
	// 打印描述信息
	xiaoMi->description();

	MobilePhone * huaWei = factory->manufacturePhone(HUAWEI);
	huaWei->description();

	MobilePhone *iphone = factory->manufacturePhone(IPHONE);
	iphone->description();


	// 释放内存
	delete factory;
	delete xiaoMi;
	delete huaWei;
	delete iphone;

	system("pause");
	return 0;
}

运行结果：

简单工厂模式虽然简单明了，但是如果需要增加类的话，就得去修改生产手机工厂中类了，这就违反了开闭原则，所以衍生了工厂方法模式。

---

工厂方法模式

工厂方法模式，不再只是由一个手机生产的工厂生产手机了，而是每种品牌都有自己的生产工厂，也就是说简单工厂模式中的工厂类不再使用他了，而是使用它的子类进行各自的生产手机。

既你想生产什么手机就生产什么手机，完全不会涉及到其他手机厂商，如果有删除或者增加手机品牌，完全不需要去修改其他手机厂商的代码，这就很好的体现了开闭原则。

可以使用在任何需要new对象的项目中！

如下面的UML图：

此时手机生产工厂不再运作，而是交由他的子类们运作生产。

看代码就懂了：

#include <iostream>
#include <Windows.h>

using namespace std;

//enum PHONE_TYPE {
//	MIUI,
//	HUAWEI,
//	IPHONE
//};

// 手机类
class MobilePhone {
public:
	virtual void description() = 0;		// 纯虚函数
};

// 小米手机类
class Miui : public MobilePhone {
public:
	void description() {				// 描述信息
		cout << "小米手机" << endl;
	}
};

// 华为手机类
class Huawei : public MobilePhone {
public:
	void description() {
		cout << "华为手机" << endl;
	}
};

// 苹果手机类
class Iphone : public MobilePhone {
public:
	void description() {
		cout << "苹果手机" << endl;
	}
};



// 手机生产工厂
class Factory {
public:
	virtual MobilePhone *manufacturePhone() = 0;	// 纯虚函数
};


// 小米手机生产工厂
class MiuiFactory : public Factory {
public:

	// 生产小米手机（生成小米手机对象返回）
	MobilePhone *manufacturePhone() {
		return (new Miui());
	}
};


// 华为手机生产工厂
class HuaweiFactory : public Factory {
public:

	// 生产华为手机（生成华为手机对象返回）
	MobilePhone* manufacturePhone() {
		return (new Huawei());
	}
};


// 苹果手机生产工厂
class IphoneFactory : public Factory {
public:

	// 生产苹果手机（生成苹果手机对象返回）
	MobilePhone* manufacturePhone() {
		return (new Iphone());
	}
};



int main(void) {
	// 定义工厂指针对象
	Factory *factory = new MiuiFactory;
	// 工厂对象调用manufacturePhone方法给父类指针对象分配对象
	MobilePhone *xiaoMi = factory->manufacturePhone();
	// 打印描述信息
	xiaoMi->description();


	// 从新给工厂对象分配对象
	factory = new HuaweiFactory;
	MobilePhone *huaWei = factory->manufacturePhone();
	huaWei->description();


	// 从新给工厂对象分配对象
	factory = new IphoneFactory;
	MobilePhone *iphone = factory->manufacturePhone();
	iphone->description();


	// 释放内存
	delete factory;
	delete xiaoMi;
	delete huaWei;
	delete iphone;

	system("pause");
	return 0;
}

运行结果：

---

抽象工厂模式

抽象工厂模式是工厂方法模式的升级版。

也就是说，抽象工厂模式他不再仅限于生产手机，他还可以生产电脑、音箱、电视机等等。它不再是局限于生产一种类型的生产工厂。

下面我们以上面的手机工厂为基础，在拓展出一个升级版的手机生产工厂，手机二代，毕竟手机也是需要更新换代的嘛。

请看UML类图：

跟工厂方法模式的类图差不多，就是多了一个升级版的手机类。

看代码就懂了：

#include <iostream>
#include <Windows.h>

using namespace std;


// 手机类
class MobilePhone {
public:
	virtual void description() = 0;		// 纯虚函数
};

// 小米手机类
class Miui : public MobilePhone {
public:
	void description() {				// 描述信息
		cout << "小米手机" << endl;
	}
};

// 华为手机类
class Huawei : public MobilePhone {
public:
	void description() {
		cout << "华为手机" << endl;
	}
};

// 苹果手机类
class Iphone : public MobilePhone {
public:
	void description() {
		cout << "苹果手机" << endl;
	}
};


// 升级版手机类
class NewMobilePhone {
public:
	virtual void newDescription() = 0;
};


// 升级版小米手机类
class NewMiui : public NewMobilePhone {
public:
	void newDescription() {
		cout << "小米手机二代" << endl;
	}
};


// 升级版华为手机类
class NewHuawei : public NewMobilePhone {
public:
	void newDescription() {
		cout << "华为手机二代" << endl;
	}
};


// 升级版苹果手机类
class NewIphone : public NewMobilePhone {
public:
	void newDescription() {
		cout << "苹果手机二代" << endl;
	}
};


// 手机生产工厂
class Factory {
public:

	virtual MobilePhone *manufacturePhone() = 0;	// 纯虚函数

	virtual NewMobilePhone *newManufacturePhone() = 0;	// 纯虚函数
};


// 小米手机生产工厂
class MiuiFactory : public Factory {
public:

	// 生产小米手机（生成小米手机对象返回）
	MobilePhone *manufacturePhone() {
		return (new Miui());
	}

	// 生产升级版小米手机（生成小米手机二代对象返回）
	NewMobilePhone *newManufacturePhone() {
		return (new NewMiui());
	}
};


// 华为手机生产工厂
class HuaweiFactory : public Factory {
public:

	// 生产华为手机（生成华为手机对象返回）
	MobilePhone *manufacturePhone() {
		return (new Huawei());
	}


	// 生产升级版华为手机（生成华为手机二代对象返回）
	NewMobilePhone *newManufacturePhone() {
		return (new NewHuawei());
	}
};


// 苹果手机生产工厂
class IphoneFactory : public Factory {
public:

	// 生产苹果手机（生成苹果手机对象返回）
	MobilePhone *manufacturePhone() {
		return (new Iphone());
	}


	// 生产升级版苹果手机（生成苹果手机二代对象返回）
	NewMobilePhone *newManufacturePhone() {
		return (new NewIphone());
	}
};



int main(void) {
	// 定义工厂指针对象
	Factory *factory = new MiuiFactory;
	// 生产小米手机
	MobilePhone *xiaoMi = factory->manufacturePhone();
	// 生产小米手机二代
	NewMobilePhone *newXiaoMi = factory->newManufacturePhone();
	xiaoMi->description();
	newXiaoMi->newDescription();


	// 给工厂对象分配华为手机对象
	factory = new HuaweiFactory;
	MobilePhone *huaWei = factory->manufacturePhone();
	NewMobilePhone *newHuaWei = factory->newManufacturePhone();
	huaWei->description();
	newHuaWei->newDescription();


	// 给工厂对象分配苹果手机对象
	factory = new IphoneFactory;
	MobilePhone* iphone = factory->manufacturePhone();
	NewMobilePhone* newIphone = factory->newManufacturePhone();
	iphone->description();
	newIphone->newDescription();


	// 释放内存
	delete factory;
	delete xiaoMi;
	delete newXiaoMi;
	delete huaWei;
	delete newHuaWei;
	delete iphone;
	delete newIphone;

	system("pause");
	return 0;
}

运行结果：

---

总结：
到了这里，貌似工厂模式中的三种用法也讲完，不知道观看此片博文的朋友有没有看懂呢？按一个方向去想，工厂模式就是生成对象返回的；这样想会不会明白一点呢。
一定要记住，开发中工厂模式是很常用的一种设计模式，必须要学会！

重在理解吧，先把代码搞懂了，在去看类图，两者想着结合，相信一定会看懂的。