设计模式——工厂模式 （C++实现）

软件领域中的设计模式为开发人员提供了一种使用专家设计经验的有效途径。设计模式中运用了面向对象编程语言的重要特性：封装、继承、多态，真正领悟设计模式的精髓是可能一个漫长的过程，需要大量实践经验的积累。

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

 

#include "stdafx.h"
#include <iostream>
using namespace std;

enum CpuCoreType{COREA,COREB};

//Cpu核心类
class CpuCore
{
public:
    virtual void Show() = 0;
};
//Cpu核心A类
class CpuCoreA:public CpuCore
{
public:
    void Show()
    {
        cout <<"CpuCore A " << endl;
    }
};
//Cpu核心B类
class CpuCoreB : public CpuCore
{
public:
    void Show()
    {
        cout <<"CpuCore B" << endl;
    }
};
//唯一的工厂，可以生产两种型号的处理器核，在内部判断
class Factory
{
public:
    CpuCore* CreateCpuCore(enum CpuCoreType type )
    {
        if(type == COREA)
            return new CpuCoreA();
        else if(type == COREB)
            return new CpuCoreB();
        else
            return NULL;
    };
};
class Test
{
public:
    CpuCore* pCpuCore;
    Factory factory;
public:
    void TestFactory()
    {
        pCpuCore = factory.CreateCpuCore(COREA);
        pCpuCore->Show();
        pCpuCore = factory.CreateCpuCore(COREB);
        pCpuCore->Show();
    }    
};
int _tmain(int argc, _TCHAR* argv[])
{
    Test test;
    test.TestFactory();
    cin.get();
    return 0;
}

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

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

#include "stdafx.h"
#include <iostream>
using namespace std;

enum CpuCoreType{COREA,COREB};

//Cpu核心类
class CpuCore
{
public:
    virtual void Show() = 0;
};
//Cpu核心A类
class CpuCoreA:public CpuCore
{
public:
    void Show()
    {
        cout <<"CpuCore A " << endl;
    }
};
//Cpu核心B类
class CpuCoreB : public CpuCore
{
public:
    void Show()
    {
        cout <<"CpuCore B" << endl;
    }
};
//抽象工厂方法
class Factory
{
public:
    virtual    CpuCore* CreateCpuCore() = 0;
};
//生产A核心的工厂
class FactoryA : public Factory
{
public:
    CpuCoreA* CreateCpuCore()
    {
        return new CpuCoreA();
    }
};
//生产B核心的工厂
class FactoryB : public Factory
{
public:
    CpuCoreB* CreateCpuCore()
    {
        return new CpuCoreB();
    }
};
class Test
{
public:
    CpuCore* pCpuCore;
    FactoryA factoryA;
    FactoryB factoryB;
public:
    void TestFactory()
    {
        CpuCoreA* pCoreA = factoryA.CreateCpuCore();
        CpuCoreB* pCoreB = factoryB.CreateCpuCore();
        pCoreA->Show();
        pCoreB->Show();
    }    
};
int _tmain(int argc, _TCHAR* argv[])
{
    Test test;
    test.TestFactory();
    cin.get();
    return 0;
}

 

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

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

#include "stdafx.h"
#include <iostream>
using namespace std;

enum CpuCoreType{COREA,COREB};

//单核Cpu核心类
class CpuCore
{
public:
    virtual void Show() = 0;
};
//Cpu核心A类
class CpuCoreA:public CpuCore
{
public:
    void Show()
    {
        cout <<"CpuCore A " << endl;
    }
};
//Cpu核心B类
class CpuCoreB : public CpuCore
{
public:
    void Show()
    {
        cout <<"CpuCore B" << endl;
    }
};
//多核Cpu核心类
class MultiCpuCore
{
public:
    virtual void Show() = 0;
};
//多核Cpu核心A类
class MultiCpuCoreA : public MultiCpuCore
{
public:
    void Show()
    {
        cout <<"Multi CpuCore A" << endl;
    }
};
//多核Cpu核心B类
class MultiCpuCoreB : public MultiCpuCore
{
public:
    void Show()
    {
        cout <<"Multi CpuCore B" << endl;
    }
};
//工厂，抽象工厂方法
class Factory
{
public:
    virtual    CpuCore* CreateCpuCore() = 0;
    virtual MultiCpuCore* CreateMultiCpuCore() = 0;
};
//工厂A，专门用来生产A类型的处理器
class FactoryA : public Factory
{
public:
    CpuCore* CreateCpuCore()
    {
        return new CpuCoreA();
    }
    MultiCpuCore* CreateMultiCpuCore()
    {
        return new MultiCpuCoreA();
    }
};
//工厂B，专门用来生产B类型的处理器
class FactoryB : public Factory
{
public:
    CpuCore* CreateCpuCore()
    {
        return new CpuCoreB();
    }
    MultiCpuCore* CreateMultiCpuCore()
    {
        return new MultiCpuCoreB();
    }
};
class Test
{
public:
    CpuCore* pCpuCore;
    FactoryA factoryA;
    FactoryB factoryB;
public:
    void TestFactory()
    {
        CpuCore* pCoreA = factoryA.CreateCpuCore();
        MultiCpuCore* pMultiCoreA = factoryA.CreateMultiCpuCore();
        CpuCore* pCoreB = factoryB.CreateCpuCore();
        MultiCpuCore* pMultiCoreB = factoryB.CreateMultiCpuCore();
        pCoreA->Show();
        pCoreB->Show();
        pMultiCoreA->Show();
        pMultiCoreB->Show();
    }    
};
int _tmain(int argc, _TCHAR* argv[])
{
    Test test;
    test.TestFactory();
    cin.get();
    return 0;
}

 

转载于:https://www.cnblogs.com/JczmDeveloper/p/3157041.html