1、定义

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

2、介绍

应用实例：工作了，为了参加一些聚会，肯定有两套或多套衣服吧，比如说有商务装（成套，一系列具体产品）、时尚装（成套，一系列具体产品），甚至对于一个家庭来说，可能有商务女装、商务男装、时尚女装、时尚男装，这些也都是成套的，即一系列具体产品。假设一种情况（现实中是不存在的，要不然，没法进入共产主义了，但有利于说明抽象工厂模式），在您的家中，某一个衣柜（具体工厂）只能存放某一种这样的衣服（成套，一系列具体产品），每次拿这种成套的衣服时也自然要从这个衣柜中取出了。用 OO 的思想去理解，所有的衣柜（具体工厂）都是衣柜类的（抽象工厂）某一个，而每一件成套的衣服又包括具体的上衣（某一具体产品），裤子（某一具体产品），这些具体的上衣其实也都是上衣（抽象产品），具体的裤子也都是裤子（另一个抽象产品）。

优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。

使用场景： 1、QQ 换皮肤，一整套一起换。 2、生成不同操作系统的程序。

注意事项：产品族难扩展，产品等级易扩展。

3、源码

3.1、头文件

IHuman.h

#pragma once
class IHuman
{
public:

    IHuman(void)
    {
    }

    virtual ~IHuman(void)
    {
    }

    virtual void Laugh() = 0;
    virtual void Cry() = 0;
    virtual void Talk() = 0;
    virtual void Sex() = 0;
};

YellowHuman.h

#pragma once
#include "ihuman.h"
class CYellowHuman :public IHuman
{
public:
	CYellowHuman(void)
	{
	}
	~CYellowHuman(void)
	{
	}
	void Laugh()
	{
		cout << "黄色人种会大笑，幸福呀！" << endl;
	}
	void Cry()
	{
		cout << "黄色人种会哭" << endl;
	}
	void Talk()
	{
		cout << "黄色人种会说话，一般说的都是双字节" << endl;
	}
	virtual void Sex() = 0;
};

YellowFemaleHuman.h

#pragma once
#include "yellowhuman.h"
class CYellowFemaleHuman :
	public CYellowHuman
{
public:
	CYellowFemaleHuman(void)
	{
	}
	~CYellowFemaleHuman(void)
	{
	}
	void Sex()
	{
		cout << "该黄种人的性别为女..." << endl;
	}
};

YellowMaleHuman.h

#pragma once
#include "yellowhuman.h"
class CYellowMaleHuman :
    public CYellowHuman
{
public:
    CYellowMaleHuman(void)
    {
    }
    ~CYellowMaleHuman(void)
    {
    }
    void Sex()
    {
        cout << "该黄种人的性别为男..." << endl;
    }
};

WhiteHuman.h

#pragma once
#include "ihuman.h"
class CWhiteHuman :
    public IHuman
{
public:
    CWhiteHuman(void)
    {
    }
    ~CWhiteHuman(void)
    {
    }
    void Laugh()
    {
        cout << "白色人种会大笑，侵略的笑声" << endl;
    }
    void Cry()
    {
        cout << "白色人种会哭" << endl;
    }
    void Talk()
    {
        cout << "白色人种会说话，一般都是单字节" << endl;
    }
    virtual void Sex() = 0;
};

WhiteFemaleHuman.h

#pragma once
#include "whitehuman.h"
#include <iostream>
using std::cout;
using std::endl;
class CWhiteFemaleHuman :
    public CWhiteHuman
{
public:
    CWhiteFemaleHuman(void)
    {
    }
    ~CWhiteFemaleHuman(void)
    {
    }
    void Sex()
    {
        cout << "该白种人的性别为女..." << endl;
    }
};

WhiteMaleHuman.h

#pragma once
#include "whitehuman.h"
class CWhiteMaleHuman :
    public CWhiteHuman
{
public:
    CWhiteMaleHuman(void)
    {
    }
    ~CWhiteMaleHuman(void)
    {
    }
    void Sex()
    {
        cout << "该白种人的性别为男..." << endl;
    }
};

IHumanFactory.h

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

StandardHumanFactory.h

#pragma once
#include "ihumanfactory.h"
#include "IHuman.h"
template<class T>
class CStandardHumanFactory :
    public IHumanFactory
{
public:
    CStandardHumanFactory(void)
    {
    }
    ~CStandardHumanFactory(void)
    {
    }
    IHuman * CreateHuman()
    {
        return new T;
    }
};

MaleHumanFactory.h

#pragma once
#include "standardhumanfactory.h"
#include "IHumanFactory.h"
template<class T>
class CMaleHumanFactory :
    public CStandardHumanFactory<T>
{
public:
    CMaleHumanFactory(void);
    ~CMaleHumanFactory(void);
    IHuman * CreateYellowHuman();
    IHuman * CreateWhiteHuman();
    IHuman * CreateBlackHuman();
};

3.2、实现

MaleHumanFactory.cpp

#include "StdAfx.h"
#include "MaleHumanFactory.h"
template<class T>
CMaleHumanFactory<T>::CMaleHumanFactory(void)
{
}
template<class T>
CMaleHumanFactory<T>::~CMaleHumanFactory(void)
{
}
template<class T>
IHuman * CMaleHumanFactory<T>::CreateYellowHuman()
{
    return CreateHuman();
}
template<class T>
IHuman * CMaleHumanFactory<T>::CreateWhiteHuman()
{
    return CreateHuman();
}
template<class T>
IHuman * CMaleHumanFactory<T>::CreateBlackHuman()
{
    return CreateHuman();
}

AbstractFactory.cpp

#include "IHuman.h"
#include "IHumanFactory.h"
#include "FemaleHumanFactory.h"
#include "MaleHumanFactory.h"
#include "MaleHumanFactory.cpp"
#include "YellowFemaleHuman.h"
#include "YellowMaleHuman.h"
#include "WhiteFemaleHuman.h"
#include "WhiteMaleHuman.h"

void DoIt()
{
	IHumanFactory *pFemaleHumanFactory = new CFemaleHumanFactory<CYellowFemaleHuman>();
	IHuman *pYellowFemaleHuman = pFemaleHumanFactory->CreateYellowHuman();
	pYellowFemaleHuman->Cry();
	pYellowFemaleHuman->Laugh();
	pYellowFemaleHuman->Talk();
	pYellowFemaleHuman->Sex();
	delete pYellowFemaleHuman;
	delete pFemaleHumanFactory;

	IHumanFactory *pMaleHumanFactory = new CMaleHumanFactory<CYellowMaleHuman>();
	IHuman *pYellowMaleHuman = pMaleHumanFactory->CreateYellowHuman();
	pYellowMaleHuman->Cry();
	pYellowMaleHuman->Laugh();
	pYellowMaleHuman->Talk();
	pYellowMaleHuman->Sex();
	delete pYellowMaleHuman;
	delete pMaleHumanFactory;

	IHumanFactory *pWhiteFemaleHumanFactory = new CMaleHumanFactory<CWhiteFemaleHuman>();
	IHuman *pWhiteFemaleHuman = pWhiteFemaleHumanFactory->CreateWhiteHuman();
	pWhiteFemaleHuman->Cry();
	pWhiteFemaleHuman->Laugh();
	pWhiteFemaleHuman->Talk();
	pWhiteFemaleHuman->Sex();
	delete pWhiteFemaleHuman;
	delete pWhiteFemaleHumanFactory;

	IHumanFactory *pWhiteMaleHumanFactory = new CMaleHumanFactory<CWhiteMaleHuman>();
	IHuman *pWhiteMaleHuman = pWhiteMaleHumanFactory->CreateWhiteHuman();
	pWhiteMaleHuman->Cry();
	pWhiteMaleHuman->Laugh();
	pWhiteMaleHuman->Talk();
	pWhiteMaleHuman->Sex();
	delete pWhiteMaleHuman;
	delete pWhiteMaleHumanFactory;
}
int main()
{
	DoIt();
	system("pause");
	return 0;
}

4、结果

参考文献：《菜鸟教程》? ?https://blog.csdn.net/phiall/article/details/52199659博客

设计模式之抽象工厂模式（AbstractFactory）