C++ 深入浅出工厂模式（初识篇）

最新推荐文章于 2024-11-09 13:08:09 发布
最新推荐文章于 2024-11-09 13:08:09 发布
阅读量98 收藏 1
点赞数 1
分类专栏： C++语法 文章标签： c++ 设计模式
原文链接：https://www.cnblogs.com/xiaolincoding/p/11524376.html
版权

C++ 深入浅出工厂模式（初识篇） - 小林coding - 博客园

初识工厂模式

我们先看工厂模式的介绍

这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

简单来说，使用了C++多态的特性，将存在继承关系的类，通过一个工厂类创建对应的子类（派生类）对象。在项目复杂的情况下，可以便于子类对象的创建。

工厂模式的实现方式可分别简单工厂模式、工厂方法模式、抽象工厂模式，每个实现方式都存在优和劣。

最近炒鞋炒的非常的火，那么以鞋厂的形式，一一分析针对每个实现方式进行分析。

简单工厂模式

具体的情形：

  • 鞋厂可以指定生产耐克、阿迪达斯和李宁牌子的鞋子。哪个鞋炒的火爆，老板就生产哪个，看形势生产。

UML图：

简单工厂模式的结构组成：

  1. 工厂类(ShoesFactory)：工厂模式的核心类，会定义一个用于创建指定的具体实例对象的接口。
  2. 抽象产品类(Shoes)：是具体产品类的继承的父类或实现的接口。
  3. 具体产品类(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;
    }
};
  • 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;
        }
    }
};
  • 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;
}
  • 输出结果：
[root@lincoding factory]# ./simpleFactory 
我是耐克球鞋，我的广告语：Just do it
我是阿迪达斯球鞋，我的广告语:Impossible is nothing
我是李宁球鞋，我的广告语：Everything is possible

工厂方法模式

具体情形：

  • 现各类鞋子抄的非常火热，于是为了大量生产每种类型的鞋子，则要针对不同品牌的鞋子开设独立的生产线，那么每个生产线就只能生产同类型品牌的鞋。

UML图：

工厂方法模式的结构组成：

  1. 抽象工厂类厂（ShoesFactory）：工厂方法模式的核心类，提供创建具体产品的接口，由具体工厂类实现。
  2. 具体工厂类（NiKeProducer\AdidasProducer\LiNingProducer）：继承于抽象工厂，实现创建对应具体产品对象的方式。
  3. 抽象产品类（Shoes）：它是具体产品继承的父类（基类）。
  4. 具体产品类（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();
    }
};
  • 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;
}
  • 输出结果：
[root@lincoding factory]# ./methodFactory 
我是耐克球鞋，我的广告语：Just do it
我是阿迪达斯球鞋，我的广告语:Impossible is nothing

抽象工厂模式

具体情形：

  • 鞋厂为了扩大了业务，不仅只生产鞋子，把运动品牌的衣服也一起生产了。

UML图：

抽象工厂模式的结构组成（和工厂方法模式一样）：

  1. 抽象工厂类厂（ShoesFactory）：工厂方法模式的核心类，提供创建具体产品的接口，由具体工厂类实现。
  2. 具体工厂类（NiKeProducer）：继承于抽象工厂，实现创建对应具体产品对象的方式。
  3. 抽象产品类（Shoes\Clothe）：它是具体产品继承的父类（基类）。
  4. 具体产品类（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;
    }
};
  • 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();
    }
};
  • 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;
}
  • 输出结果：
[root@lincoding factory]# ./abstractFactory 
我是耐克球鞋，让你酷起来！
我是耐克衣服，时尚我最在行！

总结

以上三种工厂模式，在新增产品时，都存在一定的缺陷。

  • 简单工厂模式，，需要去修改工厂类，这违背了开闭法则。
  • 工厂方式模式和抽象工厂模式，都需要增加一个对应的产品的具体工厂类，这就会增大了代码的编写量。

那么有什么好的方法，在新增产品时，即不用修改工厂类，也不用新增具体的工厂类？

笔者在实际项目中看到一个封装性非常强的工厂类，在扩展新产品时，不需要修改工厂类，也不需要新增具体的工厂类，详细内容可以跳转至C++ 深入浅出工厂模式（进阶篇）阅读。

小肥兔
关注
专栏目录
C++设计模式之工厂模式
xiaobeibei2的博客
02-25 2649
C++设计模式之工厂模式
【C++ 深入浅出】C++可以使用变量作为数组长度吗
捡起一束光的博客
02-11 1万+
首先明确一点：C++是不可以使用变量作为数组长度的 那为什么有些地方的C++用了变量做数组长度，没有报错呢？ 那是因为这是C99标准的一部分，叫做 变长数组 即 变量长度数组，这个特性是g++编译器的扩展 int n = 10; int a[n]; // Legal in g++ (with extensions), illegal in proper C++ 但在不是g++的编译器中这样用就会...
工厂模式，导出类以及调用方式！
04-30
定义一个用于创建对象的接口，让子类决定实例化哪一个类。接口定义的一般命名规范！质量保证，绝对实用。
C++ 深入浅出工厂模式（进阶篇）
qq_41607336的博客
09-23 322
C++ 深入浅出工厂模式（进阶篇） - 小林coding - 博客园 介绍 前文初始篇C++ 深入浅出工厂模式（初始篇），主要阐述了简单工厂模式、工厂方法模式和抽象工厂模式的结构、特点和缺陷等。以上三种方式，在新增产品时，要么修改工厂类，要么需新增具体的工厂类，说明工厂类的封装性还不够好。 本文进阶篇，主要是将工厂类的封装性提高，达到新增产品时，也不需要修改工厂类，不需要新增具体的工厂类。封装性高的工厂类特点是扩展性高、复用性也高。 模板工厂 针对工厂方法模式封装成模板工厂类，那么这样在新增产
c++动态库导出类的接口动态库的生成及两种调用
她的吻让他
04-28 1万+
动态库类的创建(适用初学者)(该博客是本人学习过程中自行总结,如有错误,还请斧正)(内含函数,常量的动态库生成与调用)我的环境是VS2005创建步骤:文件-&gt;新建-&gt;项目:win32控制台应用程序默认创建DLL在头文件中创建.h文件Lmath.h和111.h,在源文件中创建Lclass.cpp和lclasschild2.cpp这时解决方案应该是这样Lmath.h写入如下代码111.h写...
C++类库开发之导出类设计原则
奔跑的小河
05-26 2059
对于类库开发过程中导出类的开发规范问题。C/C++开发的DLL当初是作为函数级共享库设计的，并不能真正提供一个类所必需的信息。类层上的程序复用只有Java和C#生成的类文件才能做到。所以，当我们在用C++开发类库时经
C++：浅谈工厂模式与抽象工厂模式
linwh8的博客
04-24 5520
C++：浅谈工厂模式与抽象工厂模式标签： C++ 工厂模式 抽象工厂模式by 小威威之前写过一篇谈模式的文章：单例模式接下来我将浅显的谈谈工厂模式与抽象工厂模式。工厂模式与抽象工厂模式虽有差异，但实现的目的可以看成一致的：They offers the interface for creating a family of related objects, without explicitly spe
C++深入浅出（五）—— 动态内存管理
热门推荐
Edison's 小宇宙
10-25 1万+
C/C++内存分布，C语言中动态内存管理方式，C++中动态内存管理，operator new与operator delete函数，new和delete的实现原理，定位new表达式
C++——C++11新语法（中）
Wangx_wang的博客
11-06 1040
介绍了C++11中的引用折叠、可变模板参数、类的新功能、lambda
C++_用 using 语句继承基类的构造函数
最新发布
学海无涯
11-09 231
**默认情况下**，派生类会继承基类的所有成员，包括数据成员和函数成员，但不会继承基类的**构造函数和析构函数**，因为构造函数和析构函数的作用是创建和销毁对象，派生类通常需要有自己的构造和析构的逻辑。C++11 引入了using语句，使得派生类可以通过 using 关键字使用基类的构造函数，更方便地复用基类的构造逻辑。
常用的c++特性--＞day02
m0_69093426的博客
11-06 637
C++11中为我们提供了一个模板类叫做std::enable_shared_from_this，这个类中有一个方法叫做shared_from_this()，通过这个方法可以返回一个共享智能指针，在函数的内部就是使用weak_ptr来监测this对象，并通过调用weak_ptr的lock()方法返回一个shared_ptr对象。通过打印的结果可以知道，虽然弱引用智能指针wp3、wp4、wp5监测的资源是同一个，但是它的引用计数并没有发生任何的变化，也进一步证明了weak_ptr只是监测资源，并不管理资源。
GitLab 提交 C++ 技巧
nbspzs的专栏
11-08 308
在 GitLab 中提交 C++ 代码时，通常应只提交 源代码文件（例如 .cpp、.h）和 CMake 配置文件（例如 CMakeLists.txt），而不要提交通过 CMake 编译后的中间文件或构建产物。这样，当其他开发者克隆你的项目后，他们可以在自己的机器上使用 cmake 构建项目，而不需要下载编译产物。2. 跨平台兼容性：不同的开发者和平台可能会生成不同的编译产物，提交这些文件会造成不必要的冲突和问题。1. 在 .gitignore 文件中忽略编译生成的文件和目录。
C++ string(2)实现精讲
Jason_from_China的博客
11-06 1713
C++ string的使用我们已经讲解了，接下来我们会讲解string的实现，但是并不是每一个我都会实现，比如string删除有好几个，但是我会删除只是实现一个erase，首先是使用的次数频繁，其次是都大差不差，没有必要实现那么多，我这里只是把string整体的逻辑给实现，对string有一个更深入的了解提升代码能力和思维能力。注意事项1。
西南科技大学C++作业1——组合依赖关系实验代码
m0_74312676的博客
11-05 656
合理设计类与类的组合关系，即一个类要嵌套另一个类的对象作为成员变量，根据问题的需要可以是同一个类的多个对象(可以使用对象数组)，也可以是不同类的多个不同对象。让所设计的功能发挥作用。对学生和图书进行抽象，抽象出应有的成员变量，和基本的初始化，修改等成员函数，学生可以发起借书的操作，这是一种依赖关系，在学生类中将设计相应的成员函数体现这一功能操作，合理即可，可以用输出借书是否成功的结果，有一定示意就可以。其他操作：计算得到正确答案，输入自己的题目的答案，向题库内增加题目，在题库内删除题目，查询题库的题目。
【Effective C++】阅读笔记5
gma999的博客
11-07 898
Effective C++ 面向对象和模板相关章节
【C】无类型指针及函数指针
weixin_74154742的博客
11-07 967
（3）void* 通常用在函数的参数中，给函数参数带来很大的灵活性，当函数参数是void*，可以接受任意数据地址，但无法判断是什么类型，可以加个类型判断。（2）可以其他类型赋给无类型指针，但是无类型指针赋给有类型指针会警号；4.函数指针，定义一个数组，定义一个数组，里面每个元素存放一个函数指针。
C转C++学习笔记--基础知识摘录总结
汘荨的博客
11-07 917
C++ 中的 vector 是一种序列容器，它允许你在运行时动态地插入和删除元素。vector 是基于数组的数据结构，但它可以自动管理内存，这意味着你不需要手动分配和释放内存。与 C++ 数组相比，vector 具有更多的灵活性和功能，使其成为 C++ 中常用的数据结构之一。vector 是 C++ 标准模板库（STL）的一部分，提供了灵活的接口和高效的操作。基本特性:动态大小vector的大小可以根据需要自动增长和缩小。连续存储vector中的元素在内存中是连续存储的，这使得访问元素非常快速。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值