三种工厂模式的C++实现

原文链接

注：以后写设计模式相关的博客当以此为标准，很清晰，多谢。

引出工厂模式的设计问题

◆ 1.为了提高内聚（Cohesion）和松耦合（Coupling），我们经常会抽象出一些类的公共接口以形成抽象基类或者接口。这样我们可以通过声明一个指向基类的指针来指向实际的子类实现，达到了多态的目的。这里很容易出现的一个问题 n 多的子类继承自抽象基类，我们不得不在每次要用到子类的地方就编写诸如 new ×××;的代码。这里带来两个问题：

客户程序员必须知道实际子类的名称（当系统复杂后，命名将是一个很不好处理的问题，为了处理可能的名字冲突，有的命名可能并不是具有很好的可读性和可记忆性，就姑且不论不同程序员千奇百怪的个人偏好了）。

程序的扩展性和维护变得越来越困难。

◆ 2.还有一种情况就是在父类中并不知道具体要实例化哪一个具体的子类。这里的意思为：假设我们在类 A 中要使用到类 B，B 是一个抽象父类，在 A 中并不知道具体要实例化那一个 B 的子类，但是在类 A 的子类 D 中是可以知道的。在 A 中我们没有办法直接使用类似于 new ×××的语句，因为根本就不知道×××是什么。

转载注：很拗口，但是确实一种设计上的常见问题，应该避免。

以上两个问题也就引出了工厂模式的两个最重要的功能：

定义创建对象的接口，封装了对象的创建；

使得具体化类的工作延迟到了子类中。

对于工厂模式，为了使其能更好的解决多种情况的问题，将其分为三类：简单工厂模式（Simple Factory），工厂方法模式（Factory Method），抽象工厂模式（Abstract Factory）。下面来一一搞定。

简单工厂

        具体情形：有一个肥皂厂，生产各种肥皂，有舒肤佳，夏士莲，娜爱斯等。给这个肥皂厂建模。

        UML图如下：



对于简单设计模式的结构图，我们可以很清晰的看到它的组成：

1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。

2) 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。

3) 具体产品角色：工厂类所创建的对象就是此角色的实例。

简单设计模式存在的目的很简单：定义一个用于创建对象的接口。

缺点：对修改不封闭，新增加产品您要修改工厂。违法了鼎鼎大名的开闭法则（OCP）。

代码实现：

[cpp] view
plaincopy





#include <iostream>  

using namespace std;  

enum PRODUCTTYPE {SFJ,XSL,NAS};  

class soapBase  

{  

    public:  

    virtual ~soapBase(){};  

    virtual void show() = 0;  

};  

  

class SFJSoap:public soapBase  

{  

    public:  

    void show() {cout<<"SFJ Soap!"<<endl;}  

};  

  

class XSLSoap:public soapBase  

{  

    public:  

    void show() {cout<<"XSL Soap!"<<endl;}  

};  

  

class NASSoap:public soapBase  

{  

    public:  

    void show() {cout<<"NAS Soap!"<<endl;}  

};  

  

class Factory  

{  

    public:  

    soapBase * creatSoap(PRODUCTTYPE type)  

    {  

        switch(type)  

        {  

            case SFJ:   

                return new SFJSoap();  

                break;  

            case XSL:  

                return new XSLSoap();  

                break;  

            case NAS:  

                return new NASSoap();  

                break;  

            default:break;  

        }  

          

    }  

};  

  

int main()  

{  

    Factory factory;  

    soapBase* pSoap1 = factory.creatSoap(SFJ);  

    pSoap1->show();  

    soapBase* pSoap2 = factory.creatSoap(XSL);  

    pSoap2->show();  

    soapBase* pSoap3 = factory.creatSoap(NAS);  

    pSoap3->show();  

    delete pSoap1;  

    delete pSoap2;  

    delete pSoap3;  

    return 0;  

}  

运行结果

工厂方法模式

具体情形：最近莫名肥皂需求激增!！ 于是要独立每个生产线，每个生产线只生产一种肥皂。

UML图如下：



        其实这才是真正的工厂模式，简单工厂模式只能算是“坑爹版”的工厂模式。我们能很容易看出工厂方法模式和简单工厂模式的区别之处。工厂方法模式的应用并不是只是为了封装对象的创建，而是要把对象的创建放到子类中实现：Factory中只是提供了对象创建的接口，其实现将放在Factory的子类ConcreteFactory中进行。

对于工厂方法模式的组成：

1)抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。

2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。

3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。

4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。

缺点：每增加一种产品，就需要增加一个对象的工厂。如果这家公司发展迅速，推出了很多新的处理器核，那么就要开设相应的新工厂。在C++实现中，就是要定义一个个的工厂类。显然，相比简单工厂模式，工厂方法模式需要更多的类定义。

代码实现：

[cpp] view
plaincopy





#include <iostream>  

using namespace std;  

enum SOAPTYPE {SFJ,XSL,NAS};  

  

class soapBase  

{  

    public:  

    virtual ~soapBase(){};  

    virtual void show() = 0;  

};  

  

class SFJSoap:public soapBase  

{  

    public:  

    void show() {cout<<"SFJ Soap!"<<endl;}  

};  

  

class XSLSoap:public soapBase  

{  

    public:  

    void show() {cout<<"XSL Soap!"<<endl;}  

};  

  

class NASSoap:public soapBase  

{  

    public:  

    void show() {cout<<"NAS Soap!"<<endl;}  

};  

  

class FactoryBase  

{  

    public:  

    virtual soapBase * creatSoap() = 0;  

};  

  

class SFJFactory:public FactoryBase  

{  

    public:  

    soapBase * creatSoap()  

    {  

        return new SFJSoap();  

    }  

};  

  

class XSLFactory:public FactoryBase  

{  

    public:  

    soapBase * creatSoap()  

    {  

        return new XSLSoap();  

    }  

};  

  

class NASFactory:public FactoryBase  

{  

    public:  

    soapBase * creatSoap()  

    {  

        return new NASSoap();  

    }  

};  

  

  

  

int main()  

{  

    SFJFactory factory1;  

    soapBase* pSoap1 = factory1.creatSoap();  

    pSoap1->show();  

    XSLFactory factory2;  

    soapBase* pSoap2 = factory2.creatSoap();  

    pSoap2->show();  

    NASFactory factory3;  

    soapBase* pSoap3 = factory3.creatSoap();  

    pSoap3->show();  

    delete pSoap1;  

    delete pSoap2;  

    delete pSoap3;  

    return 0;  

}  

运行结果



 

抽象工厂模式

具体情形：这个肥皂厂发现搞牙膏也很赚钱，决定做牙膏。牙膏有高档低档，肥皂也是。现在搞两个厂房，一个生产低档的牙膏和肥皂，一个生产高档的牙膏和肥皂。

比如，厂房一生产中华牙膏、娜爱斯肥皂，厂房二生产黑人牙膏和舒肤佳牙膏

 UML图如下：



对于上面的结构图，可以看出抽象工厂模式，比前两者更为的复杂和一般性，抽象工厂模式和工厂方法模式的区别就在于需要创建对象的复杂程度上。

抽象工厂模式：给客户端提供一个接口，可以创建多个产品族中的产品对象 ，而且使用抽象工厂模式还要满足一下条件：

1)系统中有多个产品族，而系统一次只可能消费其中一族产品。

2)同属于同一个产品族的产品以其使用。

抽象工厂模式的组成（和工厂方法模式一样）：

1)抽象工厂角色：这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。

2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。

3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。

4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。

代码实现

[cpp] view
plaincopy





#include <iostream>  

using namespace std;  

enum SOAPTYPE {SFJ,XSL,NAS};  

enum TOOTHTYPE {HR,ZH};  

  

class SoapBase  

{  

    public:  

    virtual ~SoapBase(){};  

    virtual void show() = 0;  

};  

  

class SFJSoap:public SoapBase  

{  

    public:  

    void show() {cout<<"SFJ Soap!"<<endl;}  

};  

  

class NASSoap:public SoapBase  

{  

    public:  

    void show() {cout<<"NAS Soap!"<<endl;}  

};  

  

class ToothBase  

{  

    public:  

    virtual ~ToothBase(){};  

    virtual void show() = 0;  

};  

  

class HRTooth:public ToothBase  

{  

    public:  

    void show() {cout<<"Hei ren Toothpaste!"<<endl;}  

};  

  

class ChinaTooth:public ToothBase  

{  

    public:  

    void show() {cout<<"China Toothpaste!"<<endl;}  

};  

  

class FactoryBase  

{  

    public:  

    virtual SoapBase * creatSoap() = 0;  

    virtual ToothBase * creatToothpaste() = 0;  

};  

  

class FactoryA  

{  

    public:  

    SoapBase * creatSoap()  

    {  

        return new SFJSoap();  

    }  

      

    ToothBase * creatToothpaste()  

    {  

        return new HRTooth();  

    }  

};  

  

class FactoryB  

{  

    public:  

    SoapBase * creatSoap()  

    {  

        return new NASSoap();  

    }  

      

    ToothBase * creatToothpaste()  

    {  

        return new ChinaTooth();  

    }  

};  

  

  

int main()  

{  

    FactoryA factory1;  

    FactoryB factory2;  

    SoapBase *pSoap1 = NULL;  

    ToothBase *pToothpaste1 = NULL;  

    pSoap1 = factory1.creatSoap();  

    pToothpaste1 = factory1.creatToothpaste();  

    pSoap1->show();  

    pToothpaste1->show();  

      

    SoapBase *pSoap2 = NULL;  

    ToothBase *pToothpaste2 = NULL;  

    pSoap2 = factory2.creatSoap();  

    pToothpaste2 = factory2.creatToothpaste();  

    pSoap2->show();  

    pToothpaste2->show();  

      

    delete pSoap1;  

    delete pSoap2;  

    delete pToothpaste1;  

    delete pToothpaste2;  

      

    return 0;  

}  

运行结果

参考

C++设计模式 http://www.weixueyuan.net/cpp/shejimoshi/

设计模式C++实现（1）——工厂模式 - http://blog.csdn.net/wuzhekai1985/article/details/6660462