设计模式C++（Factory Method工厂方法模式）

此文章转载自：http://www.cnblogs.com/wanggary/archive/2011/04/11/2013033.html

工厂方法模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

解释：

main()，女娲

IHuman，产品接口

CYellowHuman，产品之一

CWhiteHuman，产品之二

CBlackHuman，产品之三

IHumanFactory，工厂接口

CYellowHumanFactory，工厂之一

CWhiteHumanFactory，工厂之二

CBlackHumanFactory，工厂之三

看代码：

//IHuman.h

#pragma once
class IHuman
{
public:
    IHuman(void)
    {
    }
    virtual ~IHuman(void)
    {
    }
    virtual void Laugh() = 0;
    virtual void Cry() = 0;
    virtual void Talk() = 0;
};

//YellowHuman.h

#pragma once
#include "IHuman.h"
class CYellowHuman : public IHuman
{
public:
	CYellowHuman(void);
	~CYellowHuman(void);
	void Laugh();
	void Cry();
	void Talk();
};

//YellowHuman.cpp

#include <iostream>
#include "YellowHuman.h"

using namespace std;

CYellowHuman::CYellowHuman(void){}
CYellowHuman::~CYellowHuman(void){}
void CYellowHuman::Laugh()
{
	cout << "黄色人种会哭" << endl;
}
void CYellowHuman::Cry()
{
	cout << "黄色人种会大笑，幸福呀" << endl;
}
void CYellowHuman::Talk()
{
	cout << "黄色人种会说话，一般说的都是双字节" << endl;
}

//WhiteHuman.h

#pragma once
#include "IHuman.h"

class CWhiteHuman : public IHuman
{
public:
	CWhiteHuman(void);
	~CWhiteHuman(void);
	void Laugh();
	void Cry();
	void Talk();
};

//WhiteHuman.cpp


#include "WhiteHuman.h"
#include <iostream>

using namespace std;

CWhiteHuman::CWhiteHuman(void)
{
}
CWhiteHuman::~CWhiteHuman(void)
{
}
void CWhiteHuman::Cry()
{
	cout << "白色人种会哭" << endl;
}
void CWhiteHuman::Laugh()
{
	cout << "白色人种会大笑，侵略的笑声" << endl;
}
void CWhiteHuman::Talk()
{
	cout << "白色人种会说话，一般都是单字节" << endl;
}

//BlackHuman.h

#pragma once
#include "ihuman.h"

class CBlackHuman : public IHuman
{
public:
	CBlackHuman(void);
	~CBlackHuman(void);
	void Laugh();
	void Cry();
	void Talk();
};

//BlackHuman.cpp

#include <iostream>
#include "BlackHuman.h"
using std::cout;
using std::endl;

CBlackHuman::CBlackHuman(void)
{
}
CBlackHuman::~CBlackHuman(void)
{
}
void CBlackHuman::Cry()
{
	cout << "黑人会哭" << endl;
}
void CBlackHuman::Laugh()
{
	cout << "黑人会笑" << endl;
}
void CBlackHuman::Talk()
{
	cout << "黑人可以说话，一般人听不懂" << endl;
}

//IHumanFactory.h

#pragma once
#include "IHuman.h"
class IHumanFactory
{
public:
	IHumanFactory(void){}
	virtual ~IHumanFactory(void){}
	virtual IHuman* CreateHuman() = 0;
};

//YellowHumanFactory.h

#pragma once
#include "IHumanFactory.h"

class CYellowHumanFactory : public IHumanFactory
{
public:
	CYellowHumanFactory(void);
	~CYellowHumanFactory(void);
	IHuman* CreateHuman(void);
};

//YellowHumanFactory.cpp

#include "YellowHumanFactory.h"
#include "YellowHuman.h"

CYellowHumanFactory::CYellowHumanFactory(void)
{
}
CYellowHumanFactory::~CYellowHumanFactory(void)
{
}
IHuman * CYellowHumanFactory::CreateHuman(void)
{
	return new CYellowHuman();
}

//WhiteHumanFactory.h

#pragma once
#include "IHumanFactory.h"

class CWhiteHumanFactory : public IHumanFactory
{
public:
	CWhiteHumanFactory(void);
	~CWhiteHumanFactory(void);
	IHuman * CreateHuman(void);
};

//WhiteHumanFactory.cpp

#include "WhiteHumanFactory.h"
#include "WhiteHuman.h"

CWhiteHumanFactory::CWhiteHumanFactory(void)
{
}
CWhiteHumanFactory::~CWhiteHumanFactory(void)
{
}
IHuman* CWhiteHumanFactory::CreateHuman(void)
{
	return new CWhiteHuman();
}

//BlackHumanFactory.h

#pragma once
#include "IHumanFactory.h"

class CBlackHumanFactory : public IHumanFactory
{
public:
	CBlackHumanFactory(void);
	~CBlackHumanFactory(void);
	IHuman * CreateHuman();
};

//BlackHumanFactory.cpp

#include "BlackHumanFactory.h"
#include "BlackHuman.h"

CBlackHumanFactory::CBlackHumanFactory(void)
{
}
CBlackHumanFactory::~CBlackHumanFactory(void)
{
}
IHuman * CBlackHumanFactory::CreateHuman()
{
	return new CBlackHuman();
}

//FactoryMethod.cpp

#include "IHuman.h"
#include "YellowHuman.h"
#include "WhiteHuman.h"
#include "BlackHuman.h"
#include "IHumanFactory.h"
#include "YellowHumanFactory.h"
#include "WhiteHumanFactory.h"
#include "BlackHumanFactory.h"
#include <iostream>
using std::cout;
using std::endl;
using std::string;

void DoFactoryMethod1()
{
	cout << "----------第一批人是这样的：黄种人工厂来生产黄种人" << endl;
	IHumanFactory *pHumanFactory = new CYellowHumanFactory();
	IHuman *pHuman = pHumanFactory->CreateHuman();
	pHuman->Cry();
	pHuman->Laugh();
	pHuman->Talk();
	delete pHuman;
	delete pHumanFactory;
}
void DoFactoryMethod2()
{
	cout << "----------第二批人是这样的：白种人工厂来生产白种人" << endl;
	IHumanFactory *pHumanFactory = new CWhiteHumanFactory();
	IHuman *pHuman = pHumanFactory->CreateHuman();
	pHuman->Cry();
	pHuman->Laugh();
	pHuman->Talk();
	delete pHuman;
	delete pHumanFactory;
}
void DoFactoryMethod3()
{
	cout << "----------第一批人是这样的：黑种人工厂来生产黑种人" << endl;
	IHumanFactory *pHumanFactory = new CBlackHumanFactory();
	IHuman *pHuman = pHumanFactory->CreateHuman();
	pHuman->Cry();
	pHuman->Laugh();
	pHuman->Talk();
	delete pHuman;
	delete pHumanFactory;
}
int main()
{
	//工厂方法
	cout << "----------工厂方法：" << endl;
	DoFactoryMethod1();
	DoFactoryMethod2();
	DoFactoryMethod3();
	return 0;
}

工厂方法的UML图：