抽象工厂模式和工厂方法

所有的工厂模式都是用来封装对象的创建。

简单工厂模式：简单工厂模式算不上一种设计模式，是将创建对方的方法放在一个工厂类里边，客户需要一个工厂类的成员变量来实现创建对象。

工厂方法模式：abstract Product factoryMethod(String type)定义了一个创建对象的接口，通过子类决定该创建什么对象。工厂方法必须返回一个产品基类。
抽象工厂模式：创建一个工厂接口，用于创建相关对象家族，而不需要明确指定具体类。接口中每一个方法都是工厂方法。

工厂方法模式：定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。共创方法让类把实例化推迟到子类。

IHumanFactory.h

#ifndef _IHUMANFACTORY
#define _IHUMANFACTORY
#include "IHuman.h"

class HumanFactory
{
public:
HumanFactory() {}
virtual ~HumanFactory() {}

virtual Human* createHuman() = 0;
};

#endif // _IHUMANFACTORY

例如在上面的HumanFactory类中定义了一个工厂方法virtual Human* createHuman() = 0。这个工厂方法用来处理对象的创建，并将这样的行为封装在了子类中。

例如：

IBlackHumanFactory.h

#ifndef _IBLACKHUMANFACTORY
#define _IBLACKHUMANFACTORY
#include "IHumanFactory.h"
#include "IBlackHuman.h"

class BlackHumanFactory : public HumanFactory
{
public:
BlackHumanFactory() {}
~BlackHumanFactory() {}

Human* createHuman() { return new BlackHuman();}
};

#endif // _IBLACKHUMANFACTORY

BlackHumanFactory就是HumanFactory的子类，子类的Human* createHuman()来创建对象。

抽象工厂模式：提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

抽象工厂的任务是定义一个负责创建一组产品的接口，这个接口内的每个方法都负责创建一个具体产品。

下面的例子中HumanFactory只有一个工厂方法。

类图如下所示：



代码如下。
IHuman.h

#ifndef _IHUMAN
#define _IHUMAN

class Human
{
public:
Human() {};
virtual ~Human() {};
virtual void Laugh() = 0;
};

#endif // _IHUMAN

IBlackHuman.h

#ifndef _IBLACKHUMAN
#define _IBLACKHUMAN
#include "IHuman.h"

class BlackHuman : public Human
{
public:
BlackHuman() {}
~BlackHuman() {}
void Laugh() { std::cout<<"BlackHuman Laugh!"<<std::endl; }
};

#endif // _IBLACKHUMAN

IWhiteHuman.h

#ifndef _IWHITEHUMAN
#define _IWHITEHUMAN

#include "IHuman.h"

class WhiteHuman : public Human
{
public:
WhiteHuman() {}
~WhiteHuman() {}
void Laugh() { std::cout<<"WhiteHuman Laugh!"<<std::endl; }
};

#endif // _IWHITEHUMAN

工厂类：

IHumanFactory.h

#ifndef _IHUMANFACTORY
#define _IHUMANFACTORY
#include "IHuman.h"

class HumanFactory
{
public:
HumanFactory() {}
virtual ~HumanFactory() {}

virtual Human* createHuman() = 0;
};

#endif // _IHUMANFACTORY

IBlackHumanFactory.h

#ifndef _IBLACKHUMANFACTORY
#define _IBLACKHUMANFACTORY
#include "IHumanFactory.h"
#include "IBlackHuman.h"

class BlackHumanFactory : public HumanFactory
{
public:
BlackHumanFactory() {}
~BlackHumanFactory() {}

Human* createHuman() { return new BlackHuman();}
};

#endif // _IBLACKHUMANFACTORY

IWhiteHumanFactory.h

#ifndef _IWHITEHUMANFACTORY
#define _IWHITEHUMANFACTORY
#include "IBlackHumanFactory.h"
#include "IWhiteHuman.h"

class WhiteHumanFactory : public HumanFactory
{
public:
WhiteHumanFactory() {}
~WhiteHumanFactory() {}

Human* createHuman() { return new WhiteHuman(); }
};
#endif // _IWHITEHUMANFACTORY

测试：

#include <iostream>
#include "IBlackHumanFactory.h"
#include "IWhiteHumanFactory.h"
#include "IBlackHuman.h"
#include "IWhiteHuman.h"

using namespace std;

int main()
{
BlackHumanFactory bhf;
WhiteHumanFactory whf;
Human *bh = bhf.createHuman();
Human *wh = whf.createHuman();
bh->Laugh();
wh->Laugh();
return 0;
}

结果为：

BlackHuman Laugh!

WhiteHuman Laugh!

在“资源取得时机便是初始化时机”的指引下，我们采用智能指针来管理createHuman中的new创建的资源。

IHumanFactory.h

#ifndef _IHUMANFACTORY
#define _IHUMANFACTORY
#include <memory>
#include "IHuman.h"

class HumanFactory
{
public:
HumanFactory() {}
virtual ~HumanFactory() {}

virtual std::shared_ptr<Human> createHuman() = 0;
};

#endif // _IHUMANFACTORY

IWhiteHumanFactory.h

#ifndef _IWHITEHUMANFACTORY
#define _IWHITEHUMANFACTORY
#include "IBlackHumanFactory.h"
#include "IWhiteHuman.h"

class WhiteHumanFactory : public HumanFactory
{
public:
WhiteHumanFactory() {}
~WhiteHumanFactory() {}

std::shared_ptr<Human> createHuman() { return std::make_shared<WhiteHuman>(); }
};
#endif // _IWHITEHUMANFACTORY

IBlackHumanFactory.h

#ifndef _IBLACKHUMANFACTORY
#define _IBLACKHUMANFACTORY
#include "IHumanFactory.h"
#include "IBlackHuman.h"

class BlackHumanFactory : public HumanFactory
{
public:
BlackHumanFactory() {}
~BlackHumanFactory() {}

std::shared_ptr<Human> createHuman() { return std::make_shared<BlackHuman>();}
};

#endif // _IBLACKHUMANFACTORY

test.cpp

#include <iostream>
#include "IBlackHumanFactory.h"
#include "IWhiteHumanFactory.h"
#include "IBlackHuman.h"
#include "IWhiteHuman.h"

using namespace std;

int main()
{
BlackHumanFactory bhf;
WhiteHumanFactory whf;
shared_ptr<Human> bh = bhf.createHuman();
shared_ptr<Human> wh = whf.createHuman();
bh.get()->Laugh();
wh.get()->Laugh();
return 0;
}

其中bh.get()->Laugh()是将shared_ptr<Human>显示地转换为Human*。

从此以后class*我将替换为shared_ptr<class>，new替换为make_shared<class>()，至于delete就用不着操心了。