C++ 深入浅出工厂模式（初识篇）
【摘要】 初识工厂模式
我们先看工厂模式的介绍
这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
简单来说，使用了C++多态的特性，将存在继承关系的类，通过一个工厂类创建对应的子类（派生类）对象。在项目复杂的情况下，可以便于子类对象的创建。 ...
初识工厂模式
我们先看工厂模式的介绍
这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
简单来说，使用了C++多态的特性，将存在继承关系的类，通过一个工厂类创建对应的子类（派生类）对象。在项目复杂的情况下，可以便于子类对象的创建。
工厂模式的实现方式可分别简单工厂模式、工厂方法模式、抽象工厂模式，每个实现方式都存在优和劣。
最近炒鞋炒的非常的火，那么以鞋厂的形式，一一分析针对每个实现方式进行分析。
简单工厂模式
具体的情形：
- 鞋厂可以指定生产耐克、阿迪达斯和李宁牌子的鞋子。哪个鞋炒的火爆，老板就生产哪个，看形势生产。
UML图：
简单工厂模式的结构组成：
- 工厂类(
ShoesFactory)：工厂模式的核心类，会定义一个用于创建指定的具体实例对象的接口。 - 抽象产品类(
Shoes)：是具体产品类的继承的父类或实现的接口。 - 具体产品类(
NiKeShoes\AdidasShoes\LiNingShoes)：工厂类所创建的对象就是此具体产品实例。
简单工厂模式的特点：
- 工厂类封装了创建具体产品对象的函数。
简单工厂模式的缺陷：
- 扩展性非常差，新增产品的时候，需要去修改工厂类。
简单工厂模式的代码：
Shoes为鞋子的抽象类（基类），接口函数为Show()，用于显示鞋子广告。NiKeShoes、AdidasShoes、LiNingShoes为具体鞋子的类，分别是耐克、阿迪达斯和李宁鞋牌的鞋，它们都继承于Shoes抽象类。
// 鞋子抽象类
class Shoes
{
public: virtual ~Shoes() {} virtual void Show() = 0;
};
// 耐克鞋子
class NiKeShoes : public Shoes
{
public: void Show() { std::cout << "我是耐克球鞋，我的广告语：Just do it" << std::endl; }
};
// 阿迪达斯鞋子
class AdidasShoes : public Shoes
{
public: void Show() { std::cout << "我是阿迪达斯球鞋，我的广告语:Impossible is nothing" << std::endl; }
};
// 李宁鞋子
class LiNingShoes : public Shoes
{
public: void Show() { std::cout << "我是李宁球鞋，我的广告语：Everything is possible" << std::endl; }
};
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
ShoesFactory为工厂类，类里实现根据鞋子类型创建对应鞋子产品对象的CreateShoes(SHOES_TYPE type)函数。
enum SHOES_TYPE
{ NIKE, LINING, ADIDAS
};
// 总鞋厂
class ShoesFactory
{
public: // 根据鞋子类型创建对应的鞋子对象 Shoes *CreateShoes(SHOES_TYPE type) { switch (type) { case NIKE: return new NiKeShoes(); break; case LINING: return new LiNingShoes(); break; case ADIDAS: return new AdidasShoes(); break; default: return NULL; break; } }
};
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
main函数，先是构造了工厂对象，后创建指定类型的具体鞋子产品对象，创建了具体鞋子产品的对象便可直接打印广告。因为采用的是new的方式创建了对象，用完了要通过delete释放资源资源哦！
int main()
{ // 构造工厂对象 ShoesFactory shoesFactory; // 从鞋工厂对象创建阿迪达斯鞋对象 Shoes *pNikeShoes = shoesFactory.CreateShoes(NIKE); if (pNikeShoes != NULL) { // 耐克球鞋广告喊起 pNikeShoes->Show(); // 释放资源 delete pNikeShoes; pNikeShoes = NULL; } // 从鞋工厂对象创建阿迪达斯鞋对象 Shoes *pLiNingShoes = shoesFactory.CreateShoes(LINING); if (pLiNingShoes != NULL) { // 李宁球鞋广告喊起 pLiNingShoes->Show(); // 释放资源 delete pLiNingShoes; pLiNingShoes = NULL; } // 从鞋工厂对象创建阿迪达斯鞋对象 Shoes *pAdidasShoes = shoesFactory.CreateShoes(ADIDAS); if (pAdidasShoes != NULL) { // 阿迪达斯球鞋广告喊起 pAdidasShoes->Show(); // 释放资源 delete pAdidasShoes; pAdidasShoes = NULL; } return 0;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 输出结果：
[root@lincoding factory]# ./simpleFactory
我是耐克球鞋，我的广告语：Just do it
我是阿迪达斯球鞋，我的广告语:Impossible is nothing
我是李宁球鞋，我的广告语：Everything is possible
- 1
- 2
- 3
- 4
工厂方法模式
具体情形：
- 现各类鞋子抄的非常火热，于是为了大量生产每种类型的鞋子，则要针对不同品牌的鞋子开设独立的生产线，那么每个生产线就只能生产同类型品牌的鞋。
UML图：
工厂方法模式的结构组成：
- 抽象工厂类厂（
ShoesFactory）：工厂方法模式的核心类，提供创建具体产品的接口，由具体工厂类实现。 - 具体工厂类（
NiKeProducer\AdidasProducer\LiNingProducer）：继承于抽象工厂，实现创建对应具体产品对象的方式。 - 抽象产品类（
Shoes）：它是具体产品继承的父类（基类）。 - 具体产品类（
NiKeShoes\AdidasShoes\LiNingShoes）：具体工厂所创建的对象，就是此类。
工厂方法模式的特点：
- 工厂方法模式抽象出了工厂类，提供创建具体产品的接口，交由子类去实现。
- 工厂方法模式的应用并不只是为了封装具体产品对象的创建，而是要把具体产品对象的创建放到具体工厂类实现。
工厂方法模式的缺陷：
- 每新增一个产品，就需要增加一个对应的产品的具体工厂类。相比简单工厂模式而言，工厂方法模式需要更多的类定义。
- 一条生产线只能一个产品。
工厂方法模式的代码：
ShoesFactory抽象工厂类，提供了创建具体鞋子产品的纯虚函数。NiKeProducer、AdidasProducer、LiNingProducer具体工厂类，继承持续工厂类，实现对应具体鞋子产品对象的创建。
// 总鞋厂
class ShoesFactory
{
public: virtual Shoes *CreateShoes() = 0; virtual ~ShoesFactory() {}
};
// 耐克生产者/生产链
class NiKeProducer : public ShoesFactory
{
public: Shoes *CreateShoes() { return new NiKeShoes(); }
};
// 阿迪达斯生产者/生产链
class AdidasProducer : public ShoesFactory
{
public: Shoes *CreateShoes() { return new AdidasShoes(); }
};
// 李宁生产者/生产链
class LiNingProducer : public ShoesFactory
{
public: Shoes *CreateShoes() { return new LiNingShoes(); }
};
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
main函数针对每种类型的鞋子，构造了每种类型的生产线，再由每个生产线生产出对应的鞋子。需注意的是具体工厂对象和具体产品对象，用完了需要通过delete释放资源。
int main()
{ // ================ 生产耐克流程 ==================== // // 鞋厂开设耐克生产线 ShoesFactory *niKeProducer = new NiKeProducer(); // 耐克生产线产出球鞋 Shoes *nikeShoes = niKeProducer->CreateShoes(); // 耐克球鞋广告喊起 nikeShoes->Show(); // 释放资源 delete nikeShoes; delete niKeProducer; // ================ 生产阿迪达斯流程 ==================== // // 鞋厂开设阿迪达斯生产者 ShoesFactory *adidasProducer = new AdidasProducer(); // 阿迪达斯生产线产出球鞋 Shoes *adidasShoes = adidasProducer->CreateShoes(); // 阿迪达斯球鞋广喊起 adidasShoes->Show(); // 释放资源 delete adidasShoes; delete adidasProducer; return 0;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 输出结果：
[root@lincoding factory]# ./methodFactory
我是耐克球鞋，我的广告语：Just do it
我是阿迪达斯球鞋，我的广告语:Impossible is nothing
- 1
- 2
- 3
抽象工厂模式
具体情形：
- 鞋厂为了扩大了业务，不仅只生产鞋子，把运动品牌的衣服也一起生产了。
UML图：
抽象工厂模式的结构组成（和工厂方法模式一样）：
- 抽象工厂类厂（
ShoesFactory）：工厂方法模式的核心类，提供创建具体产品的接口，由具体工厂类实现。 - 具体工厂类（
NiKeProducer）：继承于抽象工厂，实现创建对应具体产品对象的方式。 - 抽象产品类（
Shoes\Clothe）：它是具体产品继承的父类（基类）。 - 具体产品类（
NiKeShoes\NiKeClothe）：具体工厂所创建的对象，就是此类。
抽象工厂模式的特点：
- 提供一个接口，可以创建多个产品族中的产品对象。如创建耐克工厂，则可以创建耐克鞋子产品、衣服产品、裤子产品等。
抽象工厂模式的缺陷：
- 同工厂方法模式一样，新增产品时，都需要增加一个对应的产品的具体工厂类。
抽象工厂摸是的代码：
Clothe和Shoes，分别为衣服和鞋子的抽象产品类。NiKeClothe和NiKeShoes，分别是耐克衣服和耐克衣服的具体产品类。
// 基类 衣服
class Clothe
{
public: virtual void Show() = 0; virtual ~Clothe() {}
};
// 耐克衣服
class NiKeClothe : public Clothe
{
public: void Show() { std::cout << "我是耐克衣服，时尚我最在行！" << std::endl; }
};
// 基类 鞋子
class Shoes
{
public: virtual void Show() = 0; virtual ~Shoes() {}
};
// 耐克鞋子
class NiKeShoes : public Shoes
{
public: void Show() { std::cout << "我是耐克球鞋，让你酷起来！" << std::endl; }
};
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
Factory为抽象工厂，提供了创建鞋子CreateShoes()和衣服产品CreateClothe()对象的接口。NiKeProducer为具体工厂，实现了创建耐克鞋子和耐克衣服的方式。
// 总厂
class Factory
{
public: virtual Shoes *CreateShoes() = 0;
virtual Clothe *CreateClothe() = 0; virtual ~Factory() {}
};
// 耐克生产者/生产链
class NiKeProducer : public Factory
{
public: Shoes *CreateShoes() { return new NiKeShoes(); } Clothe *CreateClothe() { return new NiKeClothe(); }
};
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
main函数，构造耐克工厂对象，通过耐克工厂对象再创建耐克产品族的衣服和鞋子对象。同样，对象不再使用时，需要手动释放资源。
int main()
{ // ================ 生产耐克流程 ==================== // // 鞋厂开设耐克生产线 Factory *niKeProducer = new NiKeProducer(); // 耐克生产线产出球鞋 Shoes *nikeShoes = niKeProducer->CreateShoes();
// 耐克生产线产出衣服 Clothe *nikeClothe = niKeProducer->CreateClothe(); // 耐克球鞋广告喊起 nikeShoes->Show();
// 耐克衣服广告喊起 nikeClothe->Show(); // 释放资源 delete nikeShoes;
delete nikeClothe; delete niKeProducer; return 0;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 输出结果：
[root@lincoding factory]# ./abstractFactory
我是耐克球鞋，让你酷起来！
我是耐克衣服，时尚我最在行！
- 1
- 2
- 3
总结
以上三种工厂模式，在新增产品时，都存在一定的缺陷。
- 简单工厂模式，，需要去修改工厂类，这违背了开闭法则。
- 工厂方式模式和抽象工厂模式，都需要增加一个对应的产品的具体工厂类，这就会增大了代码的编写量。
那么有什么好的方法，在新增产品时，即不用修改工厂类，也不用新增具体的工厂类？
笔者在实际项目中看到一个封装性非常强的工厂类，在扩展新产品时，不需要修改工厂类，也不需要新增具体的工厂类，详细内容可以跳转至C++ 深入浅出工厂模式（进阶篇）阅读。
文章来源: blog.csdn.net，作者：小林coding，版权归原作者所有，如需转载，请联系作者。
原文链接：blog.csdn.net/qq_34827674/article/details/100862811
【版权声明】本文为华为云社区用户转载文章，如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱：
cloudbbs@huaweicloud.com
- 点赞
- 收藏
- 关注作者
评论（0）