简单工厂(静态工厂)

Posted 2021-11-26 kuikuitage

简单工厂模式是属于创建型模式，又叫做静态工厂。是由一个工厂对象(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中定义成纯虚接口。