cocos2dx中也有工厂模式,何为工厂模式,顾名思义就是用来产生产品的,工厂就是用来创建其他类对象的类,我们把这个创建其他类对象的类叫做工厂类,而这些被创建的对象叫做产品,所以这种模式才叫做工厂模式,是不是很形象。我们从纯c++的角度来看一下如何使用工厂模式。工厂模式又分为简单工厂模式、工厂方法模式、抽象工厂模式,先来看一下简单工厂模式如何实现。

简单工厂模式:当在程序中创建对象的时候少不了new,有时候new会很多,又分布在程序的不同地方,管理起来很不方便,这个时候需要一个工厂类,专门负责对象的创建和释放,将对象的这种操作统一在一起,同时工厂类向外部提供了创建对象的接口,而对对象的使用则和这个工厂类毫无关系。

#ifndef _FACTORY_H_
#define _FACTORY_H_
#include <iostream>

using namespace std;

enum ProductType
{
	typeA,
	typeB
};

//产品类的基类
class Product
{
public:
	//存虚函数
	virtual void show()=0;
};

class ProductA : public Product
{
public:
	void show()
	{
		cout<<"ProductA\n";
	};
};

class ProductB : public Product
{
public:
	void show()
	{
		cout<<"ProductB\n";
	};
};

//工厂类,用来产生产品
class Factory
{
public:
	//根据传入的不同产品类型产生不同的对象
	Product * createProduct(ProductType type)
	{
		switch(type)
		{
		case typeA:
			return new ProductA();
		case typeB:
			return new ProductB();
		default:
			return NULL;
		}
	};
};

#endif
#include "Factory.h"

int main()
{
	Factory * factory = new Factory();
	//产生产品
	ProductA * pa = (ProductA *)factory->createProduct(typeA);
	pa->show();

	ProductB * pb = (ProductB *)factory->createProduct(typeB);
	pb->show();

	//记得析构
	delete factory;
	//产品的析构可以放到factory类的析构函数中去做
	delete pa;
	delete pb;

	return 0;
}

设计模式——工厂模式

工厂方法模式:是为了解决简单工厂模式的弊端存在的,简单工厂模式的扩展性不好,比如我们有了第三个产品ProductC,我们需要工厂为我们产生这个对象,怎么办,需要修改工厂类中的创建对象的函数,也就是switch结构,还有就是枚举处也要进行修改,而这种修改会带来不少的弊端,所以我们就有了工厂方法模式。这个模式将Factory设计为抽象类,其中包含子类必须实现的方法,而对产品的具体创建则放到Factory的子类中去完成。这个时候如果有一个产品C,我们就创建一个工厂类FactoryC,专门用来产生产品C,就不需要改动其他地方的代码了。

#ifndef _FACTORY_H_
#define _FACTORY_H_
#include <iostream>

using namespace std;

//产品类的基类
class Product
{
public:
	//存虚函数
	virtual void show()=0;
};

class ProductA : public Product
{
public:
	void show()
	{
		cout<<"ProductA\n";
	};
};

class ProductB : public Product
{
public:
	void show()
	{
		cout<<"ProductB\n";
	};
};

//工厂抽象类,定义子类必须实现的接口
class Factory
{
public:
	//根据传入的不同产品类型产生不同的对象
	virtual Product * createProduct()=0;
};

//具体的工厂类,用来产生不同的产品
class FactoryA : public Factory
{
public:
	Product * createProduct()
	{
		return new ProductA();
	};
};

class FactoryB : public Factory
{
public:
	Product * createProduct()
	{
		return new ProductB();
	};
};

#endif
#include "Factory.h"

int main()
{
	//产生产品
	FactoryA * factoryA = new FactoryA();
	Product * pa = factoryA->createProduct();
	pa->show();

	FactoryB * factoryB = new FactoryB();
	Product * pb = factoryB->createProduct();
	pb->show();

	//记得析构
	delete factoryA;
	delete factoryB;
	//产品的析构可以放到factory类的析构函数中去做
	delete pa;
	delete pb;

	return 0;
}

设计模式——工厂模式

设计模式——工厂模式

抽象工厂模式:现在我们的产品类都是继承自Product的,如果有一个产品不是Product的子类怎么办呢?这个时候就用到了抽象工厂模式,这个模式是工厂方法模式的叠加,其他的东西类似,看下代码就清楚了。

#ifndef _FACTORY_H_
#define _FACTORY_H_
#include <iostream>

using namespace std;

//产品类A类的基类
class ProductA
{
public:
	//存虚函数
	virtual void show()=0;
};

class ProductA1 : public ProductA
{
public:
	void show()
	{
		cout<<"ProductA1\n";
	};
};

class ProductA2 : public ProductA
{
public:
	void show()
	{
		cout<<"ProductA2\n";
	};
};

//产品类B类的基类
class ProductB
{
	virtual void show()=0;
};

class ProductB1 : public ProductB
{
	void show()
	{
		cout<<"ProductB1\n";
	};
};

class ProductB2 : public ProductB
{
	void show()
	{
		cout<<"ProductB2\n";
	};
};

//工厂抽象类,定义子类必须实现的接口
class Factory
{
public:
	//根据传入的不同产品类型产生不同的对象
	virtual ProductA * createProductA()=0;
	virtual ProductB * createProductB()=0;
};

//具体的工厂类,用来产生不同的产品
class FactoryA : public Factory
{
public:
	ProductA * createProductA()
	{
		return new ProductA1();
	};
	ProductB * createProductB()
	{
		return new ProductB1();
	};
};

class FactoryB : public Factory
{
public:
	ProductA * createProductA()
	{
		return new ProductA2();
	};
	ProductB * createProductB()
	{
		return new ProductB2();
	};
};

#endif

设计模式——工厂模式

以上是对工厂模式的说明,下面看看工厂模式在cocos2dx中的应用,引用cocos2d-x高级开发教程一书中的话:“工厂方法是程序设计中一个经典的设计模式,指的是基类中只定义创建对象的接口,将实际的实现推迟到子类中。在这里,我们将它稍加推广,泛指一切生成并返回一个对象的静态函数”。一切生成并返回一个对象的静态函数就是一个工厂方法,这样的话,cocos2dx中是不是有很多这样的方法?比如创建场景的createScene函数,创建多数对象的create函数,一个经典的工厂方法如同这样:

Sprite* factoryMethod()
 {
Sprite* ret = new Sprite();
//在这里对 ret 对象进行必要的初始化操作
ret->autorelease();
return ret;
 }

在我们自己的程序中使用工厂模式的应用场景可以是这样:我们要创建很多的子弹,如果使用Sprite的create方法每次都会分配内存,子弹销毁的时候释放内存,这样的创建方法效率不高,如果我们使用工厂方法来完成这件事情,自己的工厂方法立面维护一个容器,容器里存放被销毁的子弹,需要新的子弹的时候,从容器中拿出来。根据子弹的类型,更换纹理,重置位置,重置飞行速度和方向,然后发射出去。如果容器中没有被销毁的子弹,就初始化一个,这样的话就不用每次new、delete了,内存中的子弹数量是一定的,可以提高程序的效率。