简单factory

参数化工厂模式，可以解决两种问题：1.封装对对象的创建2.推迟化对象的创建

//工厂生产的一类产品
class TypeBase
{
public:
    TypeBase();
    virtual ~TypeBase();
    virtual void Speak() = 0;
};

TypeBase::TypeBase()
{
}
TypeBase::~TypeBase()
{

}
//某两种具体产品
#include"typebase.h"
class IntType:public TypeBase
{
public:
    IntType();
    ~IntType();
    void Speak();
private:
    int m_Buf;
};
#include "inttype.h"
#include<QDebug>
IntType::IntType()
{
    m_Buf = 5000;
}

IntType::~IntType()
{

}

void IntType::Speak()
{
    qDebug()<<m_Buf;
}

#include"typebase.h"
#include<QString>
class StrType:public TypeBase
{
public:
    StrType();
    ~StrType();
    void Speak();
private:
    QString m_Buf;
};
#include "strtype.h"
#include<QDebug>
StrType::StrType()
{
    m_Buf = "Hello,I am Type QString";
}
StrType::~StrType()
{

}
void StrType::Speak()
{
    qDebug()<<m_Buf;
}
//工厂采用单例模式，只有一个工厂
#include"typebase.h"
#include"strtype.h"
#include"inttype.h"
class TypeFactory
{
protected:
    TypeFactory();
public:
    static TypeFactory* GetInstance();
    TypeBase *CreateType(QString typeName);
private:
  static TypeFactory* m_Instance;
};
#include "typefactory.h"
TypeFactory* TypeFactory::m_Instance = 0;
TypeFactory::TypeFactory()
{
}

TypeFactory* TypeFactory::GetInstance()
{
    if(0 == m_Instance)
        m_Instance = new TypeFactory();
    return m_Instance;
}

TypeBase* TypeFactory::CreateType(QString typeName)
{
    if("INT" == typeName)
        return new IntType();
    else if("STRING" == typeName)
        return new StrType();
    else
        return 0;
}
//工厂使用方法：
 TypeFactory *factory = TypeFactory::GetInstance();
    TypeBase * type = factory->CreateType("INT");
    type->Speak();
    TypeBase * type2 = factory->CreateType("STRING");
    type2->Speak();