您的位置：首页 > 其它

设计模式——工厂模式

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

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

查看源代码

打印帮助

1
#ifndef_FACTORY_H_
2
#define_FACTORY_H_
3
#include<iostream>
4
5
using
namespace
std;
6
7
enum

ProductType
8
{
9
typeA,
10
typeB
11
};
12
13
//产品类的基类
14
class

Product
15
{
16
public
:
17
//存虚函数
18
virtual

void
show()=0;

19
};
20
21
class

ProductA:
public

Product
22
{
23
public
:
24
void

show()
25
{

26
cout<<
"ProductA\n"
;
27
};

28
};
29
30
class

ProductB:
public

Product
31
{
32
public
:
33
void

show()
34
{

35
cout<<
"ProductB\n"
;
36
};

37
};
38
39
//工厂类，用来产生产品
40
class

Factory
41
{
42
public
:
43
//根据传入的不同产品类型产生不同的对象
44
Product*createProduct(ProductTypetype)
45
{

46
switch
(type)
47
{
48
case

typeA:
49
return

new
ProductA();

50
case

typeB:
51
return

new
ProductB();

52
default
:
53
return

NULL;
54
}
55
};

56
};
57
58
#endif
查看源代码

打印帮助

1
#include"Factory.h"
2
3
int

main()
4
{
5
Factory*factory=
new
Factory();
6
//产生产品
7
ProductA*pa=(ProductA*)factory->createProduct(typeA);
8
pa->show();
9
10
ProductB*pb=(ProductB*)factory->createProduct(typeB);
11
pb->show();
12
13
//记得析构
14
delete

factory;
15
//产品的析构可以放到factory类的析构函数中去做
16
delete

pa;
17
delete

pb;
18
19
return

0;
20
}




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

查看源代码

打印帮助

1
#ifndef_FACTORY_H_
2
#define_FACTORY_H_
3
#include<iostream>
4
5
using
namespace
std;
6
7
//产品类的基类
8
class

Product
9
{
10
public
:
11
//存虚函数
12
virtual

void
show()=0;

13
};
14
15
class

ProductA:
public

Product
16
{
17
public
:
18
void

show()
19
{

20
cout<<
"ProductA\n"
;
21
};

22
};
23
24
class

ProductB:
public

Product
25
{
26
public
:
27
void

show()
28
{

29
cout<<
"ProductB\n"
;
30
};

31
};
32
33
//工厂抽象类，定义子类必须实现的接口
34
class

Factory
35
{
36
public
:
37
//根据传入的不同产品类型产生不同的对象
38
virtual

Product*createProduct()=0;
39
};
40
41
//具体的工厂类，用来产生不同的产品
42
class

FactoryA:
public

Factory
43
{
44
public
:
45
Product*createProduct()
46
{

47
return

new
ProductA();

48
};

49
};
50
51
class

FactoryB:
public

Factory
52
{
53
public
:
54
Product*createProduct()
55
{

56
return

new
ProductB();

57
};

58
};
59
60
#endif
查看源代码

打印帮助

1
#include"Factory.h"
2
3
int

main()
4
{
5
//产生产品
6
FactoryA*factoryA=
new
FactoryA();
7
Product*pa=factoryA->createProduct();
8
pa->show();
9
10
FactoryB*factoryB=
new
FactoryB();
11
Product*pb=factoryB->createProduct();
12
pb->show();
13
14
//记得析构
15
delete

factoryA;
16
delete

factoryB;
17
//产品的析构可以放到factory类的析构函数中去做
18
delete

pa;
19
delete

pb;
20
21
return

0;
22
}








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

查看源代码

打印帮助

1
#ifndef_FACTORY_H_
2
#define_FACTORY_H_
3
#include<iostream>
4
5
using
namespace
std;
6
7
//产品类A类的基类
8
class

ProductA
9
{
10
public
:
11
//存虚函数
12
virtual

void
show()=0;

13
};
14
15
class

ProductA1:
public

ProductA
16
{
17
public
:
18
void

show()
19
{

20
cout<<
"ProductA1\n"
;
21
};

22
};
23
24
class

ProductA2:
public

ProductA
25
{
26
public
:
27
void

show()
28
{

29
cout<<
"ProductA2\n"
;
30
};

31
};
32
33
//产品类B类的基类
34
class

ProductB
35
{
36
virtual

void
show()=0;

37
};
38
39
class

ProductB1:
public

ProductB
40
{
41
void

show()
42
{

43
cout<<
"ProductB1\n"
;
44
};

45
};
46
47
class

ProductB2:
public

ProductB
48
{
49
void

show()
50
{

51
cout<<
"ProductB2\n"
;
52
};

53
};
54
55
//工厂抽象类，定义子类必须实现的接口
56
class

Factory
57
{
58
public
:
59
//根据传入的不同产品类型产生不同的对象
60
virtual

ProductA*createProductA()=0;
61
virtual

ProductB*createProductB()=0;
62
};
63
64
//具体的工厂类，用来产生不同的产品
65
class

FactoryA:
public

Factory
66
{
67
public
:
68
ProductA*createProductA()
69
{

70
return

new
ProductA1();

71
};

72
ProductB*createProductB()
73
{

74
return

new
ProductB1();

75
};

76
};
77
78
class

FactoryB:
public

Factory
79
{
80
public
:
81
ProductA*createProductA()
82
{

83
return

new
ProductA2();

84
};

85
ProductB*createProductB()
86
{

87
return

new
ProductB2();

88
};

89
};
90
91
#endif




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

查看源代码

打印帮助

1
Sprite*factoryMethod()
2
{

3
Sprite*ret=
new

Sprite();
4
//在这里对ret对象进行必要的初始化操作
5
ret->autorelease();
6
return

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

                                        

                        
                        内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息 
                    

                    

                    

                        

                         标签： 
                                                

                        

                    


                

            


            

                
相关文章推荐

                

                
            

        

        

            

            
            

                

                    
新的分享

                    

                        
                    

                

            


            

                

                    
章节导航