抽象工厂模式（c++描述）

最新推荐文章于 2024-08-17 15:45:47 发布

blpluto

最新推荐文章于 2024-08-17 15:45:47 发布

阅读量7.5k

点赞数

分类专栏：设计模式文章标签： c++ 产品 class delete 工作

本文链接：https://blog.csdn.net/blpluto/article/details/4562111

版权

设计模式专栏收录该内容

5 篇文章 0 订阅

订阅专栏

在抽象工厂模式中，我引用从网上看来的一篇例子来说明。

随着时间的推移，走过的地方越来越多，你天南海北的朋友也越来越多。你发现菜原来还分了许多菜系，鲁菜、粤菜、湘菜等等，你招待

不同的朋友要用不同的菜系，这下难办了，你的厨师都是鲁菜风味，怎么办，广东的朋友来了吃不惯。现在我们再回到简单工厂模式，我们把

红烧肉再向下继承，生成鲁菜红烧肉、粤菜红烧肉、湘菜红烧肉；清蒸鱼向下继承为鲁菜清蒸鱼、粤菜清蒸鱼、湘菜清蒸鱼，其它也以此类

推。我们也修改一下这个类，不让其返回食物基类，而是返回红烧肉、清蒸鱼这一层次，并把这些方法抽象化，作为菜系工厂基类，然后再从

此基类继承出，鲁菜工厂、粤菜工厂、湘菜工厂等等，再由这些具体工厂实现创建具体菜的工作，哈哈你如果招待广东朋友就用粤菜工厂，返

回的就是一桌粤菜菜系的红烧肉、清蒸鱼了，你的广东朋友一定会吃的非常合乎胃口了。噢，非常好，你已经实现了抽象工厂模式了。结构模

型图也变成了的样子了。

抽象工厂模式

现在可以看到，想新来做一个菜系，只需新聘请一个厨师就可以了，多么完美，但是如果你想新增加一个菜就变得非常困难了。

实现代码：

//产品基类

#include <iostream>

class FoodProduct
{
public:
FoodProduct(void);
~FoodProduct(void);
virtual void Delicious();
};
//红烧鱼类

class BraisingFish :public FoodProduct
{
public:
BraisingFish(void);
~BraisingFish(void);
virtual void Delicious();
};

//清蒸鱼类

class SteamedFish :public FoodProduct
{
public:
SteamedFish(void);
~SteamedFish(void);
virtual void Delicious();
};
//川式清蒸鱼

class ChuanBraisingFish :public BraisingFish
{
public:
ChuanBraisingFish(void);
~ChuanBraisingFish(void);
virtual void Delicious();
};
//鲁式清蒸鱼
class LuBraisingFish :public BraisingFish
{
public:
LuBraisingFish(void);
~LuBraisingFish(void);
virtual void Delicious();
};

//川（鲁）式红烧鱼类的写法与清蒸鱼类相同

//下面实现烹饪工厂

//烹饪总工厂

class CookFactory
{
public:
CookFactory(void);
~CookFactory(void);
virtual BraisingFish *CookBraisingFish();
virtual SteamedFish *CookSteamedFish();
};

//鲁菜工厂

class LuCookFactory :public CookFactory
{
public:
LuCookFactory(void);
~LuCookFactory(void);
virtual BraisingFish *CookBraisingFish();
virtual SteamedFish *CookSteamedFish();
};
//鲁菜工厂的实现

BraisingFish *LuCookFactory::CookBraisingFish()
{
std::cout<<"The Lu BraisingFish is Cooked!"<<std::endl;
return new LuBraisingFish();
}

SteamedFish *LuCookFactory::CookSteamedFish()
{
std::cout<<"The Lu StramedFish is Cooked!"<<std::endl;

return new LuSteamedFish();
}

//川菜工厂

class ChuanCookFactory :public CookFactory
{
public:
ChuanCookFactory(void);
~ChuanCookFactory(void);
virtual BraisingFish *CookBraisingFish();
virtual SteamedFish *CookSteamedFish();
};

//川菜工厂的实现

BraisingFish *ChuanCookFactory::CookBraisingFish()
{
std::cout<<"The Chuan BraisingFish is Cooked!"<<std::endl;
return new ChuanBraisingFish();
}

SteamedFish *ChuanCookFactory::CookSteamedFish()
{
std::cout<<"The Chuan SteamedFish is Cooked!"<<std::endl;
return new ChuanSteamedFish();
}

//下面是客户端的实现

int main(void)
{
CookFactory *cookFac = new LuCookFactory();

BraisingFish *braFish = cookFac->CookBraisingFish();
braFish->Delicious();
std::cout<<"******************************************/n";
delete braFish;

SteamedFish *steFish = cookFac->CookSteamedFish();
steFish->Delicious();
std::cout<<"******************************************/n";
delete steFish;
delete cookFac;

cookFac = new ChuanCookFactory();

braFish = cookFac->CookBraisingFish();
braFish->Delicious();
std::cout<<"******************************************/n";
delete braFish;

steFish = cookFac->CookSteamedFish();
steFish->Delicious();
delete steFish;

system("pause");

return 0;
}

至此，抽象工厂模式完成。

现在可以和工厂模式对比一下，抽象工厂返回的接口不再是产品A和产品B的共同基类Product了，而是产品A、产品B基类（在工厂模式

中它们为具体实现类，这里变成了基类）了。此时工厂的抽象和简单工厂中的工厂方法也很类似，就是这些特征区使其别于工厂模式而变成抽

象工厂模式了，因此抽象工厂解决的是创建一系列有共同风格的产品（鲁菜还是粤菜），而工厂方法模式解决的创建有共同特征的一系列产品

（红烧肉、清蒸鱼它们都是食物）。当然简单工厂的缺陷在抽象工厂中又再次出现了，我要新增加一个产品，工厂抽象接口就要改变了。因此

抽象工厂并不比工厂模式完美，只不过是各自的适用领域不同而已。其实，这里如果把抽象工厂模式的接口返回产品A和产品B的共同基类

（工厂模式返回的参数），你会发现，奇怪这个模式怎么这么眼熟，它不是恰恰退化成工厂模式了。