设计模式——工厂模式

来源：互联网发布：软件测试工资水平编辑：程序博客网时间：2024/06/11 21:17

本文链接：http://www.zaojiahua.com/factory-pattern.html

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

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

1#ifndef _FACTORY_H_
2#define _FACTORY_H_
3#include <iostream>
4 
5using namespace std;
6 
7enum ProductType
8{
9    typeA,
10    typeB
11};
12 
13//产品类的基类
14class Product
15{
16public:
17    //存虚函数
18    virtual void show()=0;
19};
20 
21class ProductA : public Product
22{
23public:
24    void show()
25    {
26        cout<<"ProductA\n";
27    };
28};
29 
30class ProductB : public Product
31{
32public:
33    void show()
34    {
35        cout<<"ProductB\n";
36    };
37};
38 
39//工厂类，用来产生产品
40class Factory
41{
42public:
43    //根据传入的不同产品类型产生不同的对象
44    Product * createProduct(ProductType type)
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 
3int 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 
5using namespace std;
6 
7//产品类的基类
8class Product
9{
10public:
11    //存虚函数
12    virtual void show()=0;
13};
14 
15class ProductA : public Product
16{
17public:
18    void show()
19    {
20        cout<<"ProductA\n";
21    };
22};
23 
24class ProductB : public Product
25{
26public:
27    void show()
28    {
29        cout<<"ProductB\n";
30    };
31};
32 
33//工厂抽象类，定义子类必须实现的接口
34class Factory
35{
36public:
37    //根据传入的不同产品类型产生不同的对象
38    virtual Product * createProduct()=0;
39};
40 
41//具体的工厂类，用来产生不同的产品
42class FactoryA : public Factory
43{
44public:
45    Product * createProduct()
46    {
47        return new ProductA();
48    };
49};
50 
51class FactoryB : public Factory
52{
53public:
54    Product * createProduct()
55    {
56        return new ProductB();
57    };
58};
59 
60#endif

1#include "Factory.h"
2 
3int 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 
5using namespace std;
6 
7//产品类A类的基类
8class ProductA
9{
10public:
11    //存虚函数
12    virtual void show()=0;
13};
14 
15class ProductA1 : public ProductA
16{
17public:
18    void show()
19    {
20        cout<<"ProductA1\n";
21    };
22};
23 
24class ProductA2 : public ProductA
25{
26public:
27    void show()
28    {
29        cout<<"ProductA2\n";
30    };
31};
32 
33//产品类B类的基类
34class ProductB
35{
36    virtual void show()=0;
37};
38 
39class ProductB1 : public ProductB
40{
41    void show()
42    {
43        cout<<"ProductB1\n";
44    };
45};
46 
47class ProductB2 : public ProductB
48{
49    void show()
50    {
51        cout<<"ProductB2\n";
52    };
53};
54 
55//工厂抽象类，定义子类必须实现的接口
56class Factory
57{
58public:
59    //根据传入的不同产品类型产生不同的对象
60    virtual ProductA * createProductA()=0;
61    virtual ProductB * createProductB()=0;
62};
63 
64//具体的工厂类，用来产生不同的产品
65class FactoryA : public Factory
66{
67public:
68    ProductA * createProductA()
69    {
70        return new ProductA1();
71    };
72    ProductB * createProductB()
73    {
74        return new ProductB1();
75    };
76};
77 
78class FactoryB : public Factory
79{
80public:
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函数，一个经典的工厂方法如同这样：

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

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

0 0