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

3、抽象工厂模式:现在我们的产品类都是继承自Product的,如果有一个产品不是Product的子类怎么办呢?这个时候就用到了抽象工厂模式,这个模式是工厂方法模式的叠加,其他的东西类似,看下代码就清楚了。
以上是对工厂模式的说明,下面看看工厂模式在Cocos2d-x中的应用,引用Cocos2d-x高级开发教程一书中的话:“工厂方法是程序设计中一个经典的设计模式,指的是基类中只定义创建对象的接口,将实际的实现推迟到子类中。在这里,我们将它稍加推广,泛指一切生成并返回一个对象的静态函数”。
一切生成并返回一个对象的静态函数就是一个工厂方法,这样的话,Cocos2d-x中是不是有很多这样的方法?比如创建场景的createScene函数,创建多数对象的create函数,一个经典的工厂方法如同这样:
1、简单工厂模式:当在程序中创建对象的时候少不了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;
}

2、工厂方法模式:是为了解决简单工厂模式的弊端存在的,简单工厂模式的扩展性不好,比如我们有了第三个产品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;
}

#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

一切生成并返回一个对象的静态函数就是一个工厂方法,这样的话,Cocos2d-x中是不是有很多这样的方法?比如创建场景的createScene函数,创建多数对象的create函数,一个经典的工厂方法如同这样:
Sprite* factoryMethod()
{
Sprite* ret = new Sprite();
//在这里对ret对象进行必要的初始化操作
ret->autorelease();
return ret;
}
在我们自己的程序中使用工厂模式的应用场景可以是这样:我们要创建很多的子弹,如果使用Sprite的create方法每次都会分配内存,子弹销毁的时候释放内存,这样的创建方法效率不高,如果我们使用工厂方法来完成这件事情,自己的工厂方法里面维护一个容器,容器里存放被销毁的子弹,需要新的子弹的时候,从容器中拿出来。根据子弹的类型,更换纹理,重置位置,重置飞行速度和方向,然后发射出去。如果容器中没有被销毁的子弹,就初始化一个,这样的话就不用每次new、delete了,内存中的子弹数量是一定的,可以提高程序的效率。