Qt C++ 工厂模式

产品类：

project.h

#pragma once


#include <QDebug>


class CProject
{
public:
virtual void show() = 0;
};


class CProjectA : public CProject
{
public:
CProjectA();
void show()
{
qDebug() << "A is me";
}
};


class CProjectB : public CProject
{
public:
CProjectB();
void show()
{
qDebug() << "B is me";
}
};


class CProjectSingle
{
public:
CProjectSingle();
};


class CProjectMulti
{
public:
CProjectMulti();
};


class CProjectSingleA : public CProjectSingle
{
public:
CProjectSingleA();
};


class CProjectSingleB : public CProjectSingle
{
public:
CProjectSingleB();
};


class CProjectMultiA : public CProjectMulti
{
public:
CProjectMultiA();
};


class CProjectMultiB : public CProjectMulti
{
public:
CProjectMultiB();
};

project.cpp

#include "project.h"


CProjectA::CProjectA()
{
qDebug() << "this is a A";
}


CProjectB::CProjectB()
{
qDebug() << "this is a B";
}


CProjectSingle::CProjectSingle()
{
qDebug() << "this is a Single";
}


CProjectMulti::CProjectMulti()
{
qDebug() << "this is a Multi";
}


CProjectSingleA::CProjectSingleA()
{
qDebug() << "this is a SingleA";
}


CProjectSingleB::CProjectSingleB()
{
qDebug() << "this is a SingleB";
}


CProjectMultiA::CProjectMultiA()
{
qDebug() << "this is a MultiA";
}


CProjectMultiB::CProjectMultiB()
{
qDebug() << "this is a MultiB";
}

简单工厂：

simplefactory.h

#pragma once


#include "project.h"


class CSimpleFactory
{
public:
static CSimpleFactory* instance();
enum EProjectType
{
eprojectA,
eprojectB,
};
CProject* createProject(EProjectType type);

protected:
CSimpleFactory(){}
};

simplefactory.cpp

#include "simplefactory.h"


CSimpleFactory* CSimpleFactory::instance()
{
static CSimpleFactory* _instance=0;
if (!_instance)
{
_instance = new CSimpleFactory;
}
return _instance;
}


CProject* CSimpleFactory::createProject(EProjectType type)
{
switch(type)
{
case eprojectA:
return new CProjectA();
case eprojectB:
return new CProjectB();
default:
return 0;
}
}

工厂方法：

factorymethod.h

#pragma once


#include "project.h"


class CFactoryMethod
{
public:
virtual CProject* createProject() = 0;
};


class CFactoryMethodA : public CFactoryMethod
{
public:
static CFactoryMethod* instance();


CProject* createProject();


protected:
CFactoryMethodA(){};
};


class CFactoryMethodB : public CFactoryMethod
{
public:
static CFactoryMethod* instance();


CProject* createProject();


protected:
CFactoryMethodB(){};
};

factorymethod.cpp

#include "factorymethod.h"


CFactoryMethod* CFactoryMethodA::instance()
{
static CFactoryMethod* _instance = 0;
if (!_instance)
{
_instance = new CFactoryMethodA;
}
return _instance;
}


CProject* CFactoryMethodA::createProject()
{
return new CProjectA;
}


CFactoryMethod* CFactoryMethodB::instance()
{
static CFactoryMethod* _instance = 0;
if (!_instance)
{
_instance = new CFactoryMethodB;
}
return _instance;
}


CProject* CFactoryMethodB::createProject()
{
return new CProjectB;
}

抽象工厂：

abstractfactory.h

#pragma once


#include "project.h"


class CAbstractFactory
{
public:
virtual CProjectSingle* createSingle() = 0;
virtual CProjectMulti* createMulti() = 0;
};


class CFactoryA : public CAbstractFactory
{
public:
CFactoryA(){}
CProjectSingle* createSingle();
CProjectMulti* createMulti();
};


class CFactoryB : public CAbstractFactory
{
public:
CFactoryB(){}
CProjectSingle* createSingle();
CProjectMulti* createMulti();
};

abstractfactory.cpp

#include "abstractfactory.h"


CProjectSingle* CFactoryA::createSingle()
{
return new CProjectSingleA();
}


CProjectMulti* CFactoryA::createMulti()
{
return new CProjectMultiA();
}


CProjectSingle* CFactoryB::createSingle()
{
return new CProjectSingleB();
}


CProjectMulti* CFactoryB::createMulti()
{
return new CProjectMultiB();
}

main.cpp

#include <QApplication>


#include "abstractfactory.h"
#include "factorymethod.h"
#include "simplefactory.h"


int main(int argc,char **argv)
{
QApplication app(argc,argv);


//简单工厂
CProject *a = CSimpleFactory::instance()->createProject(CSimpleFactory::eprojectA);
CProject *b = CSimpleFactory::instance()->createProject(CSimpleFactory::eprojectB);
//工厂方法
CProject *aa = CFactoryMethodA::instance()->createProject();
CProject *bb = CFactoryMethodB::instance()->createProject();
//抽象工厂
CAbstractFactory *facA = new CFactoryA();
CProjectSingle *single1 = facA->createSingle();
CProjectMulti *mul1 = facA->createMulti();


CAbstractFactory *facB = new CFactoryB();
CProjectSingle *single2 = facB->createSingle();
CProjectMulti *mul2 = facB->createMulti();

return app.exec();
}