Cocos设计模式之工厂模式

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

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

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
#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;
}

Cocos设计模式之工厂模式

 

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

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
#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;
}

 

Cocos设计模式之工厂模式

 

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

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
#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中的应用，引用Cocos2d-x高级开发教程一书中的话：“工厂方法是程序设计中一个经典的设计模式，指的是基类中只定义创建对象的接口，将实际的实现推迟到子类中。在这里，我们将它稍加推广，泛指一切生成并返回一个对象的静态函数”。 

一切生成并返回一个对象的静态函数就是一个工厂方法，这样的话，Cocos2d-x中是不是有很多这样的方法？比如创建场景的createScene函数，创建多数对象的create函数，一个经典的工厂方法如同这样：  

 

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

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

来源网址：http://www.zaojiahua.com/factory-pattern.html

相关文章：

  • 2021-04-29
猜你喜欢
  • 2021-07-03
  • 2022-12-23
  • 2021-07-11
相关资源
相似解决方案
热门标签
Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode