工厂模式

工厂模式属于创建型设计模式。工厂模式通过提供一个公共的创建对象的接口，可以在不暴露对象创建逻辑的情况下创建对象，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。主要解决接口选择的问题。
工厂模式分为三种类型：简单工厂、方法工厂和抽象工厂，其本质就是对获取对象过程的抽象。你需要一辆汽车，可以直接从工厂里提货，而不用关心它具体是怎么实现。

// 公共接口，.h文件
enum ShapeType
{
	CIRCLE,
	SQUARE
};

class Shape
{
public:
	virtual void create() = 0;
};

class Circle : public Shape
{
public:
	virtual void create()
	{
		printf("Circle::create()\n");
	}
};

class Square : public Shape
{
public:
	virtual void create()
	{
		printf("Square::create()\n");
	}
};

// 普通实现
int main(void)
{
	//工厂生成圆形的玩具
	Shape* circle = new Circle(CIRCLE);
	circle->create();

	//工厂生产方形的玩具
	Shape* square = new Square(SQUARE);
	square->create();

	return 0;
}

简单工厂模式

简单工厂模式是简单的一种工厂模式，它定义了一个负责生产对象的工厂类，使用者可以根据不同参数来创建并返回不同子类，这些子类都共用一个接口。

/* 工厂模式。工厂要生成玩具，玩具到形状不同，有圆形，有方形 */
class ShapeFactory
{
public:
	Shape* getShape(ShapeType type)
	{
		switch (type)
		{
		case CIRCLE:
			return (new Circle());
		case SQUARE:
			return (new Square());
		default:
			return NULL;
		}
	}
};

int main(void)
{
	ShapeFactory shapeFactory;

	//工厂生成圆形的玩具
	Shape* circle = shapeFactory.getShape(CIRCLE);
	circle->create();

	//工厂生产方形的玩具
	Shape* square = shapeFactory.getShape(SQUARE);
	square->create();

	return 0;
}

方法工厂模式

一个派生类就代表着一个工厂，每个工厂都有具体要生产的产品。
生产其他形状玩具时，不用考虑圆形和方形玩具，只需要增加一个新的工厂就行了。

//工厂方法：
class Factory
{
public:
	virtual Shape* createShape(ShapeType type) = 0;
};

// Circle工厂
class CircleFactory : public Factory
{
public:
	Shape* createShape(ShapeType type);
	{
		return new Circle(name);
	}
};
// Square工厂
class SquareFactory : public Factory
{
public:
	Shape* createCar(ShapeType type)
	{
		return new Square(name);
	}
};
 
void main()
{
	Shape* circle = new CircleFactory(CIRCLE);
  circle->create();

	Shape* square = new SquareFactory(SQUARE);
  square->create();
}

抽象工厂模式

抽象工厂模式是一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。
接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

/*
抽象工厂模式：
工厂要生成玩具，
玩具的形状不同，有圆形，有方形；
玩具的颜色也不同，有黑色，有白色
*/
#include 

enum Type
{
	SHAPE,
	COLOR
};

enum ShapeType
{
	CIRCLE,
	SQUARE
};

enum ColorType
{
	BLACK,
	WHITE
};

class Shape
{
public:
	virtual void create() = 0;
};

class Circle : public Shape
{
public:
	virtual void create()
	{
		printf("Circle::create()\n");
	}
};

class Square : public Shape
{
public:
	virtual void create()
	{
		printf("Square::create()\n");
	}
};

class Color
{
public:
	virtual void create() = 0;
};

class Black : public Color
{
public:
	virtual void create()
	{
		printf("Black::create()\n");
	}
};

class White : public Color
{
public:
	virtual void create()
	{
		printf("White::create()\n");
	}
};

class Factory
{
public:
	virtual Shape* getShape(ShapeType type) = 0;
	virtual Color* getColor(ColorType type) = 0;
};

class ShapeFactory : public Factory
{
public:
	Shape* getShape(ShapeType type)
	{
		switch (type)
		{
		case CIRCLE:
			return (new Circle());
		case SQUARE:
			return (new Square());
		default:
			return NULL;
		}
	}
	Color* getColor(ColorType type)
	{
		return NULL;
	}
};

class ColorFactory : public Factory
{
public:
	Shape* getShape(ShapeType type)
	{
		return NULL;
	}
	Color* getColor(ColorType type)
	{
		switch (type)
		{
		case BLACK:
			return (new Black());
		case WHITE:
			return (new White());
		default:
			return NULL;
		}
	}
};

//工厂生成器类，通过传递形状或颜色生成玩具
class FactoryProduct
{
public:
	static Factory* getFactory(Type type)
	{
		switch (type)
		{
		case SHAPE:
			return (new ShapeFactory());
		case COLOR:
			return (new ColorFactory());
		default:
			return NULL;
		}
	}
};

int main(int argc, char** argv)
{
	//获取形状工厂
	Factory* shapeFactory = FactoryProduct::getFactory(SHAPE);
	Shape *shape1 = shapeFactory->getShape(CIRCLE);
	shape1->create();
	Shape *shape3 = shapeFactory->getShape(SQUARE);
	shape3->create();

	//获取颜色工厂
	Factory* colorFactory = FactoryProduct::getFactory(COLOR);
	Color* color1 = colorFactory->getColor(BLACK);
	color1->create();
	Color* color2 = colorFactory->getColor(WHITE);
	color2->create();

	return 0;
}