简单工厂(静态工厂)

简单工厂模式是属于创建型模式，又叫做静态工厂。是由一个工厂对象(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;
protected:
    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;
}

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(string name);
    ~CImpSamA();
};

class CImpSamB : public IBase
{
public:
    CImpSamB(string name);
    ~CImpSamB();
};
#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;
}

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

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

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)
    {
        cout << pImp->getName() << endl;
    }
    delete pImp;
    pImp = NULL;

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

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

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

    return a.exec();
}

以上class CFactory便是简单工厂或静态工厂实现，Factory具名名字空间和全局名字空间只是工厂实现位置不同而已。外部只调用工厂提供的接口，只需要包含factory.h和base.h即可实现创建具体对象。不依赖具体实现imp.h 。

优点："聚合"了创建工作（内聚到了工厂），和松耦合（依赖共同的抽象接口，不依赖具体实现）。
缺点：将不同对象创建"聚"到一个工厂，而非"内聚"到各对象的内部实现。违反了"高内聚"，而且工厂中只能创建已知的类，否则需要修改工厂类，违反了"对扩展开放，对修改封闭"原则。

注意点：

• 实现上可以是类静态成员函数或者是普通全局或者具名名字空间的函数。
• 不能定义成全局静态：全局静态限制作用域为当前文件，main中调用链接会报未定义错误
• 构造函数 protected，virtual虚析构。
• 必须要实现的函数需在base中定义成纯虚接口。