设计模式：工厂模式-（简单工厂、工厂方法、抽象工厂）

• 缘起：在看caffe源码时遇到了工程模式，于是查找学习了下。本文主要是将一个别人写的java demo改写成了c++ 版本。
• 参照博客：简书博客
• note：要是初学工厂模式的话看上边的链接就好了，上边博客写的通俗易懂，我主要是改写了实现语言。
• 1、简单工厂模式
  • 定义：
    　　定义一个工厂类，根据传入的参数不同返回不同的实例，被创建的实例具有共同的父类或接口。
  • 适用场景：
    　　其实由定义也大概能推测出其使用场景，首先由于只有一个工厂类，所以工厂类中创建的对象不能太多，否则工厂类的业务逻辑就太复杂了，其次由于工厂类封装了对象的创建过程，所以客户端应该不关心对象的创建。总结一下适用场景：
    • （1）需要创建的对象较少。
    • （2）客户端不关心对象的创建过程。
  • 实例：
    　　创建一个可以绘制不同形状的绘图工具，可以绘制圆形，正方形，三角形，每个图形都会有一个draw()方法用于绘图，不看代码先考虑一下如何通过该模式设计完成此功能。

#ifndef __DRAW_SHAPE_HPP__
#define __DRAW_SHAPE_HPP__
#include<iostream>
#include<string>

class Shape {
public:
	virtual void draw() {};
};

class CircleShape : public Shape {
public:
	CircleShape() {
		std::cout << "circleShape create!" << std::endl;
	}
	void draw() {
		std::cout << "draw circle." << std::endl;
	}
};

class RectShape :public Shape {
public:
	RectShape() { std::cout << "rectShape create!" << std::endl; }
	void draw() { std::cout << "draw rect." << std::endl; }
};

class TrianShape :public Shape {
public:
	TrianShape() { std::cout << "trianShape create!" << std::endl; }
	void draw() { std::cout << "draw trangle." << std::endl; }
};

class ShapeFactory {
public:
	static Shape* getshape(std::string str) {
		if (str == "cricle")
		{
			Shape* pshape = new CircleShape();
			return pshape;
		}
		else if (str == "rect") {
			Shape* pshape = new RectShape();
			return pshape;
		}
		else if (str == "tran") {
			Shape* pshape = new TrianShape();
			return pshape;
		}
		else {
			std::cout << "input error!" << std::endl;
			return NULL;
		}
	}
};

#endif//__DRAW_SHAPE_HPP__

#include "draw_shape.hpp"

int main(int argc, char* argv[])
{
	Shape* pshape = ShapeFactory::getshape("cricle");
	pshape->draw();

	//Shape* pshape = ShapeFactory::getshape("rect");
	//pshape->draw();

	//Shape* pshape = ShapeFactory::getshape("tran");
	//pshape->draw();

	system("pause");
	return 0;
}

• 2、工厂方法模式
  • 说明：工厂方法模式是简单工厂的进一步深化， 在工厂方法模式中，我们不再提供一个统一的工厂类来创建所有的对象，而是针对不同的对象提供不同的工厂。也就是说每个对象都有一个与之对应的工厂。
  • 定义：
    　　定义一个用于创建对象的接口，让子类决定将哪一个类实例化。工厂方法模式让一个类的实例化延迟到其子类。
    　　这次我们先用实例详细解释一下这个定义，最后在总结它的使用场景。
  • 实例：
    　　现在需要设计一个这样的图片加载类，它具有多个图片加载器，用来加载jpg，png，gif格式的图片，每个加载器都有一个read（）方法，用于读取图片。下面我们完成这个图片加载类。
  • 适用场景：
    （1）客户端不需要知道它所创建的对象的类。例子中我们不知道每个图片加载器具体叫什么名，只知道创建它的工厂名就完成了床架过程。
    　　（2）客户端可以通过子类来指定创建对应的对象。
    以上场景使用于采用工厂方法模式。

#ifndef __READ_HPP__
#define __READ_HPP__

#include<iostream>
#include<string>

class Reader {
public:
	Reader() { std::cout << "Reader create!" << std::endl;}
	virtual void read() {};
};

class JpgReader : public Reader {
public:
	JpgReader() { std::cout << "JpgReader create!" << std::endl; }
	void read() { std::cout << "read JPG." << std::endl; }
};

class PngReader :public Reader {
public:
	PngReader() { std::cout << "PngReader create!" << std::endl; }
	void read() { std::cout << "read PNG." << std::endl; }
};

class GifReader : public Reader {
public:
	GifReader() { std::cout << "GifReader create!" << std::endl;}
	void read() { std::cout << "read GIF." << std::endl; }
};

class ReaderFactory {
public:
	virtual Reader* getReader()=0;
};

class JpgReaderFactory :public ReaderFactory {
public:
	Reader* getReader() {
		Reader* preader = new JpgReader();
		return preader;
	}
};

class PngReaderFactory: public ReaderFactory{
public:
	Reader* getReader() {
		Reader* preader = new PngReader();
		return preader;
	}
};

class GifReaderFactory :public ReaderFactory {
public:
	Reader* getReader() {
		Reader* preader = new GifReader();
		return preader;
	}
};

#endif

#include "read.hpp"

int main(int argc, char* argv[])
{
	ReaderFactory* factory = new JpgReaderFactory();
	Reader* reader = factory->getReader();
	reader->read();
	system("pause");
	return 0;
}	

• 3、抽象工厂模式
  • 说明：因为这个模式并不符合开闭原则。实际开发还需要做好权衡。
    　　抽象工厂模式是工厂方法的进一步深化，在这个模式中的工厂类不单单可以创建一个对象，而是可以创建一组对象。这是和工厂方法最大的不同点。
  • 定义：
    　　提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。（ 在抽象工厂模式中，每一个具体工厂都提供了多个工厂方法用于产生多种不同类型的对象）
    　　
    抽象工厂和工厂方法一样可以划分为4大部分：
    AbstractFactory（抽象工厂）声明了一组用于创建对象的方法，注意是一组。
    ConcreteFactory（具体工厂）：它实现了在抽象工厂中声明的创建对象的方法，生成一组具体对象。
    AbstractProduct（抽象产品）：它为每种对象声明接口，在其中声明了对象所具有的业务方法。
    ConcreteProduct（具体产品）：它定义具体工厂生产的具体对象。
    下面还是先看一个具体实例。
  • 实例：
    　　现在需要做一款跨平台的游戏，需要兼容Android，Ios，Wp三个移动操作系统，该游戏针对每个系统都设计了一套操作控制器（OperationController）和界面控制器（UIController），下面通过抽闲工厂方式完成这款游戏的架构设计。
    由题可知，游戏里边的各个平台的UIController和OperationController应该是我们最终生产的具体产品。所以新建两个抽象产品接口。
  • 适用场景：
    （1）和工厂方法一样客户端不需要知道它所创建的对象的类。
    （2）需要一组对象共同完成某种功能时。并且可能存在多组对象完成不同功能的情况。
    （3）系统结构稳定，不会频繁的增加对象。（因为一旦增加就需要修改原有代码，不符合开闭原则）

#ifndef __CONTROLLER_HPP__
#define __CONTROLLER_HPP__
#include<iostream>
#include<string>

class OperationController {
public:
	virtual void control() {};
};

class UIController {
public:
	virtual void display() {};
};

//Android operationController and UIController
class AndroidOperationController :public OperationController {
public:
	void control() { std::cout << "AndroidOperationController." << std::endl; }
};

class AndroidUIController :public UIController {
public:
	void display() { std::cout << "AndroidInterfaceController." << std::endl; }
};

//Ios operationController and UIController
class IosOperationController :public OperationController {
public:
	void control() { std::cout << "IosOperationController." << std::endl; }
};

class IosUIController :public UIController {
public:
	void display() { std::cout << "IosInterfaceController." << std::endl; }
};

//Wp operationController and UIController
class WpOperationController :public OperationController {
public:
	void control() { std::cout << "WpOperationController." << std::endl; }
};

class WpUIController :public UIController {
public:
	void display() { std::cout << "WpInterfaceController." << std::endl; }
};


//factory 
class SystemFactory {
public:
	virtual OperationController* createOperationController() { return NULL; };
	virtual UIController* createUIController() { return NULL; };
};

//Android Factroy
class AndroidFactory :public SystemFactory {
public:
	OperationController* createOperationController() {
		return new AndroidOperationController();
	}
	UIController* createUIController() {
		return new AndroidUIController();
	};
};

//Ios Factroy
class IosFactory :public SystemFactory {
public:
	OperationController* createOperationController() {
		return new IosOperationController();
	}
	UIController* createUIController() {
		return new IosUIController();
	};
};

//Wp Factroy
class WpFactory :public SystemFactory {
public:
	OperationController* createOperationController() {
		return new WpOperationController();
	}
	UIController* createUIController() {
		return new WpUIController();
	};
};


#endif

#include "controller.hpp"

int main(int argc, char* argv[])
{
	//for android
	SystemFactory* factory = new AndroidFactory();
	UIController* uicontrol = factory->createUIController();
	OperationController* oper_control = factory->createOperationController();

	uicontrol->display();
	oper_control->control();

	system("pause");
	return 0;
}