简单工厂(静态工厂)

Posted kuikuitage

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了简单工厂(静态工厂)相关的知识,希望对你有一定的参考价值。

简单工厂模式是属于创建型模式,又叫做静态工厂是由一个工厂对象(Factory)决定创建出哪一种产品类(Product)的实例。

设计模式可以结合具体场景进行分析,但不要局限在具体场景中,本文直接使用模型进行说明,相对抽象,但对举一反三有好处。

base.h

#ifndef BASE_H
#define BASE_H

#include <string>
using namespace std;

class IBase
{
public:
    virtual ~IBase();
    virtual const string& getName() const;
    virtual void setName(const string& name);
protected:
    IBase();
    IBase(const string& name);
private:
    string m_name;
};

#endif // BASE_H

base.cpp

#include <iostream>
#include "base.h"

const string& IBase::getName() const
{
    return m_name;
}

void IBase::setName(const string& name)
{
    m_name = name;
}

IBase::IBase()
{
    cout << "constructor IBase" << endl;
}

IBase::IBase(const string& name)
{
    m_name = name;
}

IBase::~IBase()
{
    cout << "destructor IBase" << endl;
}

imp.h

#ifndef IMP_H
#define IMP_H

#include "base.h"

class CImpSamA : public IBase
{
public:
    CImpSamA();
    CImpSamA(string name);
    ~CImpSamA();
    //void FuncSetName(const string& name);
};

class CImpSamB : public IBase
{
public:
    CImpSamB();
    CImpSamB(string name);
    ~CImpSamB();
    //void FuncPrintName() const;
};
#endif // IMP_H

imp.cpp

#include <iostream>
#include "imp.h"

CImpSamA::CImpSamA(string name):IBase(name)
{
    cout << "constructor CImpSamA " << endl;
}

CImpSamA::~CImpSamA()
{
    cout << "destructor CImpSamA " << endl;
}

#if 0
void CImpSamA::FuncSetName(const string& name)
{
    setName(name);
}
#endif

CImpSamB::CImpSamB(string name):IBase(name)
{
    cout << "constructor CImpSamB " << endl;
}

CImpSamB::~CImpSamB()
{
    cout << "destructor CImpSamB " << endl;
}
#if 0
void CImpSamB::FuncPrintName()
{
    cout << getName() << endl;
}
#endif

factory.h

#ifndef FACTORY
#define FACTORY

#include "base.h"
//*注意不能定义成全局静态:全局静态限制作用域为当前文件,main中调用链接会报未定义错误
//使用类的静态成员函数
class CFactory
{
public:
    static IBase* Create(const string& name);
};
//使用具名名字空间中的函数
namespace Factory
{
    IBase* CreateImpA();
}
//直接定义在全局名字空间
IBase* CreateImpB();

#endif // FACTORY

factory.cpp

#include <iostream>
#include "imp.h"
#include "factory.h"

IBase* CFactory::Create(const string& name)
{
    IBase* pImp = NULL;
    if(name.compare("IMPA"))
    {
        pImp = new CImpSamA(name);
    }
    else if(name.compare("IMPB"))
    {
        pImp = new CImpSamB(name);
    }
    else
    {
        cout << "Not matched " << name << endl;
    }
    return pImp;
}

namespace Factory
{
    IBase* CreateImpA()
    {
        return new CImpSamA("CIMPA");
    }
}

IBase* CreateImpB()
{
    return new CImpSamB("CIMPB");
}

main.cpp

#include <QCoreApplication>
#include <iostream>
#include "factory.h"

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    //静态成员函数方法
    IBase* pImp = CFactory::Create("IMPA");
    if(NULL != pImp)
    {
        pImp->setName("New IMPA");
        cout << pImp->getName() << endl;
    }

    pImp = CFactory::Create("IMPB");
    if(NULL != pImp)
    {
        cout << pImp->getName() << endl;
    }

    //全局|静态方法
    pImp = Factory::CreateImpA();
    cout << pImp->getName() << endl;

    pImp = ::CreateImpB();
    cout << pImp->getName() << endl;

    return a.exec();
}

以上class CFactory便是简单工厂或静态工厂实现,Factory具名名字空间和全局名字空间只是工厂实现位置不同而已。

工厂类是关键,包含了必要的逻辑判断,将依赖的具体类型创建工作转移到工厂中去处理,外部只调用工厂提供的接口,只需要包含factory.h和base.h即可实现创建具体对象。不依赖具体实现imp.h
优点:"聚合"了创建工作(内聚到了工厂),和松耦合(依赖共同的抽象接口,不依赖具体实现)。
缺点:将不同对象创建"聚"到一个工厂,而非"内聚"到各对象的内部实现。违反了"高内聚",而且工厂中只能创建已知的类,否则需要修改工厂类,违反了"对扩展开放,对修改封闭"原则。

注意点:

  • 实现上不能定义成全局或者非类名的具名名字空间的静态函数,可以是类静态成员函数或者是普通全局或者具名名字空间的函数。
  • 构造函数 protected,virtual虚析构。
  • 必须需要实现的函数需在base中定义成纯虚接口。

以上是关于简单工厂(静态工厂)的主要内容,如果未能解决你的问题,请参考以下文章

深入理解设计模式-简单工厂模式(静态工厂方法模式)

工厂模式

Java:Effective java学习笔记之 静态工厂方法的简单理解和使用

简单工厂模式(静态工厂模式)

简单工厂(静态工厂)

简单工厂(静态工厂)