设计模式1(C++) 三种工厂模式

 设计模式的一些基本原则：

设计模式的六大原则（开闭原则、里氏代换原则、依赖倒转原则、单一职责原则、接口隔离原则、迪米特法则）

1. 单一职责原则

   1. 一个类只有一个职责，不应既做这又做那，这样的好处是：

   2. 降低了类的复杂性

   3. 提高了代码的可读性，可维护性

   4. 降低了因变更带来的风险

2. 里氏替换原则

   1. 一个子类必须实现父类的所有方法

   2. 一个子类可以拥有父类没有的方法

   3. 在所有需要父类对象的地方都可以用子类的对象替换而不会出现问题

3. 依赖倒置原则

   1. 高层模块不应该依赖底层模块

   2. 抽象不应该依赖于细节

   3. 实现应该依赖于抽象

   4. 面向接口编程

4. 接口隔离原则

   1. 一个类可以有多个方法，但如果打算向外部提供部分方法，则把这些方法实现为接口，返回接口类型

5. 迪米特法则

   1. 最少知识法则
   2. 只与你直接的朋友通信
   3. 一个类不应该与过多的类发生联系
   4. 如果一个类需要调用第三个类的方法，可以加入中间者，转发调用这个方法

6. 开关原则

   1. 最重要的一个核心原则
   2. 一个软件实体应该对扩展开放，对修改封闭

7. 组合优先于继承

8. 把变与不变的事物分开

1. 工厂模式

软件领域中的设计模式为开发人员提供了一种使用专家设计经验的有效途径。设计模式中运用了面向对象编程语言的重要特性：封装、继承、多态，真正领悟设计模式的精髓是可能一个漫长的过程，需要大量实践经验的积累。最近看设计模式的书，对于每个模式，用C++写了个小例子，加深一下理解。主要参考《大话设计模式》和《设计模式:可复用面向对象软件的基础》两本书。本文介绍工厂模式的实现。

       工厂模式属于创建型模式，大致可以分为三类，简单工厂模式、工厂方法模式、抽象工厂模式。听上去差不多，都是工厂模式。下面一个个介绍，首先介绍简单工厂模式，它的主要特点是需要在工厂类中做判断，从而创造相应的产品。当增加新的产品时，就需要修改工厂类。有点抽象，举个例子就明白了。有一家生产处理器核的厂家，它只有一个工厂，能够生产两种型号的处理器核。客户需要什么样的处理器核，一定要显示地告诉生产工厂。下面给出一种实现方案。

#include <iostream>
#include <chrono>
#include <thread>
#include <mutex>
#include <pthread.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <error.h>
#include <vector>
#include <algorithm>
#include <sstream>
#include <string>
using namespace std;


enum CTYPE {COREA, COREB};
class CSingleCore
{
public:
    CSingleCore(){ cout << "CSingleCore()" << endl; }
    /* C++析构函数的自动调用（析构函数必须是虚拟的，这样删除父类指针指向的子类对象，
     * 才能同时调用两者的析构函数，否则就没有机会调用子类析构函数）
     * 因此,建议子类继承父类时,父类的析构函数为虚函数.
     * 有些情况下,如果父类的析构函数不是虚函数,那么就会没有机会调用子类析构函数,造成内存泄漏.
     */
    virtual ~CSingleCore(){ cout << "~CSingleCore()" << endl; }
    virtual void Show() = 0;
};
//单核A
class CSingleCoreA: public CSingleCore
{
public:
    CSingleCoreA(){ cout << "CSingleCoreA()" << endl; }
    ~CSingleCoreA(){ cout << "~CSingleCoreA()" << endl; }
    void Show() { cout<<"CSingleCoreA Show()"<<endl; }
};
//单核B
class CSingleCoreB: public CSingleCore
{
public:
    CSingleCoreB(){ cout << "CSingleCoreB()" << endl; }
    ~CSingleCoreB(){ cout << "~CSingleCoreB()" << endl; }
    void Show() { cout<<"CSingleCoreB Show()"<<endl; }
};
//唯一的工厂，可以生产两种型号的处理器核，在内部判断
class CFactory
{
public:
    CSingleCore* CreateCSingleCore(enum CTYPE ctype)
    {
        if(ctype == COREA) //工厂内部判断
            return new CSingleCoreA(); //生产核A
        else if(ctype == COREB)
            return new CSingleCoreB(); //生产核B
        else
            return NULL;
    }
};

int main(int argc, char *argv[])
{
    CFactory fy;
    CSingleCore *sc = fy.CreateCSingleCore(COREB);
    sc->Show();
    delete sc;
    sc = NULL;
    return 0;
}

 这样设计的主要缺点之前也提到过，就是要增加新的核类型时，就需要修改工厂类。这就违反了开放封闭原则：软件实体（类、模块、函数）可以扩展，但是不可修改。于是，工厂方法模式出现了。所谓工厂方法模式，是指定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。

       听起来很抽象，还是以刚才的例子解释。这家生产处理器核的产家赚了不少钱，于是决定再开设一个工厂专门用来生产B型号的单核，而原来的工厂专门用来生产A型号的单核。这时，客户要做的是找好工厂，比如要A型号的核，就找A工厂要；否则找B工厂要，不再需要告诉工厂具体要什么型号的处理器核了。下面给出一个实现方案。

#include <iostream>
#include <chrono>
#include <thread>
#include <mutex>
#include <pthread.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <error.h>
#include <vector>
#include <algorithm>
#include <sstream>
#include <string>
using namespace std;


enum CTYPE {COREA, COREB};
class CProduct
{
public:
    CProduct(){ cout << "CProduct()" << endl; }
    /* C++析构函数的自动调用（析构函数必须是虚拟的，这样删除父类指针指向的子类对象，
     * 才能同时调用两者的析构函数，否则就没有机会调用子类析构函数）
     * 因此,建议子类继承父类时,父类的析构函数为虚函数.
     * 有些情况下,如果父类的析构函数不是虚函数,那么就会没有机会调用子类析构函数,造成内存泄漏.
     */
    virtual ~CProduct(){ cout << "~CProduct()" << endl; }
    virtual void Show() = 0;
};
//单核A
class CProductA: public CProduct
{
public:
    CProductA(){ cout << "CProductA()" << endl; }
    ~CProductA(){ cout << "~CProductA()" << endl; }
    void Show() { cout<<"CProductA Show()"<<endl; }
};
//单核B
class CProductB: public CProduct
{
public:
    CProductB(){ cout << "CProductB()" << endl; }
    ~CProductB(){ cout << "~CProductB()" << endl; }
    void Show() { cout<<"CProductB Show()"<<endl; }
};
// 简单工厂模式.唯一的工厂，可以生产两种型号的处理器核，在内部判断
class CSimpleFactory
{
public:
    CSimpleFactory(){ cout << "CSimpleFactory()" << endl; }
    ~CSimpleFactory(){ cout << "~CSimpleFactory()" << endl; }
    CProduct* CreateCProduct(enum CTYPE ctype)
    {
        if(ctype == COREA) //工厂内部判断
            return new CProductA(); //生产核A
        else if(ctype == COREB)
            return new CProductB(); //生产核B
        else
            return NULL;
    }
};

// 工厂方法模式
class CFactoryMethod
{
public:
    CFactoryMethod(){ cout << "CFactoryMethod()" << endl; }
    virtual ~CFactoryMethod(){ cout << "~CFactoryMethod()" << endl; }
    virtual CProduct* CreateProduct() = 0;
};

//生产A核的工厂
class CFactoryA : public CFactoryMethod
{
public:
    CFactoryA(){  cout << "CFactoryA()" << endl; }
    ~CFactoryA(){  cout << "~CFactoryA()" << endl; }
    CProduct* CreateProduct() {
        return new CProductA();
    }
};

//生产B核的工厂
class CFactoryB : public CFactoryMethod
{
public:
    CFactoryB(){  cout << "CFactoryB()" << endl; }
    ~CFactoryB(){  cout << "~CFactoryB()" << endl; }
    CProduct* CreateProduct() {
        return new CProductB();
    }
};

int main(int argc, char *argv[])
{
    // simple factory
//    CSimpleFactory fy;
//    CProduct *sc = fy.CreateCProduct(COREB);
//    sc->Show();
//    delete sc;
//    sc = NULL;

    // factory method
    CFactoryMethod *fma = new CFactoryA();
    CProduct *scm = fma->CreateProduct();
    scm->Show();

    delete scm;
    scm = NULL;

    delete fma;
    fma = NULL;
    return 0;
}

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

       既然有了简单工厂模式和工厂方法模式，为什么还要有抽象工厂模式呢？它到底有什么作用呢？还是举这个例子，这家公司的技术不断进步，不仅可以生产单核处理器，也能生产多核处理器。现在简单工厂模式和工厂方法模式都鞭长莫及。抽象工厂模式登场了。它的定义为提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。具体这样应用，这家公司还是开设两个工厂，一个专门用来生产A型号的单核多核处理器，而另一个工厂专门用来生产B型号的单核多核处理器，下面给出实现的代码。

#include <iostream>
#include <chrono>
#include <thread>
#include <mutex>
#include <pthread.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <error.h>
#include <vector>
#include <algorithm>
#include <sstream>
#include <string>
using namespace std;

enum CTYPE {COREA, COREB};
class CSingleCore
{
public:
    CSingleCore(){ cout << "CSingleCore()" << endl; }
    /* C++析构函数的自动调用（析构函数必须是虚拟的，这样删除父类指针指向的子类对象，
     * 才能同时调用两者的析构函数，否则就没有机会调用子类析构函数）
     * 因此,建议子类继承父类时,父类的析构函数为虚函数.
     * 有些情况下,如果父类的析构函数不是虚函数,那么就会没有机会调用子类析构函数,造成内存泄漏.
     */
    virtual ~CSingleCore(){ cout << "~CSingleCore()" << endl; }
    virtual void Show() = 0;
};
//单核A
class CSingleCoreA: public CSingleCore
{
public:
    CSingleCoreA(){ cout << "CSingleCoreA()" << endl; }
    ~CSingleCoreA(){ cout << "~CSingleCoreA()" << endl; }
    void Show() { cout<<"CSingleCoreA Show()"<<endl; }
};
//单核B
class CSingleCoreB: public CSingleCore
{
public:
    CSingleCoreB(){ cout << "CSingleCoreB()" << endl; }
    ~CSingleCoreB(){ cout << "~CSingleCoreB()" << endl; }
    void Show() { cout<<"CSingleCoreB Show()"<<endl; }
};

class CMultiCore
{
public:
    CMultiCore() { cout << "CMultiCore()" << endl; }
    virtual ~CMultiCore() { cout << "~CMultiCore()" << endl; }
    virtual void Show() = 0;
};

class MultiCoreA : public CMultiCore
{
public:
    MultiCoreA() {cout << "MultiCoreA()" << endl;}
    ~MultiCoreA() {cout << "~MultiCoreA()" << endl;}
    void Show() {cout<<"MultiCoreA Show()"<<endl;}
};

class MultiCoreB : public CMultiCore
{
public:
    MultiCoreB() {cout << "MultiCoreB()" << endl;}
    ~MultiCoreB() {cout << "~MultiCoreB()" << endl;}
    void Show() { cout<<"MultiCoreB Show()"<<endl; }
};

class CoreFactory
{
public:
    CoreFactory(){cout << "CoreFactory()" << endl;}
    virtual ~CoreFactory(){cout << "~CoreFactory()" << endl;}
    virtual CSingleCore* CreateSingleCore() = 0;
    virtual CMultiCore* CreateMultiCore() = 0;
};

//工厂A，专门用来生产A型号的处理器
class CFactoryA : public CoreFactory
{
public:
    CFactoryA(){  cout << "CFactoryA()" << endl; }
    ~CFactoryA(){  cout << "~CFactoryA()" << endl; }
    CSingleCore* CreateSingleCore() {
        return new CSingleCoreA();
    }
     CMultiCore* CreateMultiCore() { return new MultiCoreA(); }
};

//工厂B，专门用来生产B型号的处理器
class CFactoryB : public CoreFactory
{
public:
    CFactoryB(){  cout << "CFactoryB()" << endl; }
    ~CFactoryB(){  cout << "~CFactoryB()" << endl; }
    CSingleCore* CreateSingleCore() {
        return new CSingleCoreB();
    }
    CMultiCore* CreateMultiCore() { return new MultiCoreB(); }
};

int main(int argc, char *argv[])
{
    CoreFactory *cfy = new CFactoryB();
    CMultiCore *mc = cfy->CreateMultiCore();
    mc->Show();
    if(mc != NULL)
    {
        delete mc;
        mc = NULL;
    }
    if(cfy != NULL)
    {
        delete cfy;
        cfy = NULL;
    }
    return 0;
}

 

  至此，工厂模式介绍完了。利用Rational Rose 2003软件，给出三种工厂模式的UML图，加深印象。        

简单工厂模式的UML图：

         工厂方法的UML图：

         抽象工厂模式的UML图：

设计模式

设计模式资料2

设计模式资料3

设计模式的一些原则

 http://ftp.jaist.ac.jp/pub/eclipse/technology/epp/downloads/release/kepler/SR2/eclipse-cpp-kepler-SR2-linux-gtk-x86_64.tar.gz

 本文摘自15s