经典的设计模式

最新推荐文章于 2024-09-15 11:40:06 发布
最新推荐文章于 2024-09-15 11:40:06 发布
阅读量129 收藏
点赞数
分类专栏： C++编程 文章标签： c++ 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43528058/article/details/120797201
版权
本文介绍了设计模式中的简单工厂、工厂方法和抽象工厂模式，通过汽车和计算器的实例展示了如何使用这些模式。简单工厂模式在扩展时违反了开放封闭原则，因此引入了工厂方法模式，允许在不修改原有代码的情况下扩展产品。进一步地，为了解决更复杂的场景，抽象工厂模式应运而生，能够创建一系列相关的对象。文章深入浅出地阐述了三种模式的概念和应用场景。
摘要由CSDN通过智能技术生成

简单工厂模式

在这里插入图片描述

定义一个抽象类，即汽车
定义具体的汽车类型，继承自抽象类，即宝马和奔驰
定义一个工厂类，用于生产不同类型的汽车

#include <iostream>
using namespace std;
enum CarType{BENZ, BMW};
class Car//车类
{
public:
    virtual void createdCar(void) = 0;
};

class BenzCar : public Car //奔驰车
{
public:
    BenzCar()
    {
        cout<<"Benz::Benz()"<<endl;
    }
    virtual void createdCar(void)
    {
        cout<<"BenzCar::createdCar()"<<endl;
    }
    ~BenzCar()
    {

    }
};

class BmwCar : public Car //宝马车
{
public:
    BmwCar()
    {
        cout<<"Bmw::Bmw()"<<endl;
    }
    virtual void createdCar(void)
    {
        cout<<"BmwCar::createdCar()"<<endl;
    }
};


class CarFactory //车厂
{
public:
    Car* createSpecificCar(CarType type)
    {
        switch(type)
        {
        case BENZ://生产奔驰车
            return (new BenzCar());
            break;
        case BMW://生辰宝马车
            return (new BmwCar());
            break;
        default:
            return NULL;
            break;
        }
    }
};

int main(int argc, char** argv)
{
    CarFactory carfac;
    Car* specificCarA = carfac.createSpecificCar(BENZ);//看到网上众多示例在new后没有delete，感觉不是特别严谨
    Car* specificCarB = carfac.createSpecificCar(BMW);

    delete specificCarA; delete specificCarB;
    
    return 0;
}

在这里插入图片描述
为此写了一个实现计算器的代码

#include <iostream>
using namespace std;
class operation //运算的抽象类
{
public:
    double number_a=0;
    double number_b=0;
public:
    void Number_a(double a){number_a=a;}
    void Number_b(double b){number_b=b;}
    virtual double getResult(){
        return 10086;
    }
};
class operation_add:public operation // 加法
{
public:
    virtual double getResult(){
        double result=number_a+number_b;
        return result;
    }
};
class operation_sub:public operation // 减法
{
public:
    virtual double getResult(){
        double result=number_a-number_b;
        return result;
    }
};
class operation_mul:public operation // 乘法
{
public:
    virtual double getResult(){
        double result=number_a*number_b;
        return result;
    }
};
class operation_div:public operation // 除法
{
public:
    virtual double getResult(){
        if(abs(number_b)<1e-7){
            std::cout<<"divisor == 0"<<std::endl;
            return 0;
        }
        double result=number_a/number_b;
        return result;
    }
};
class operationFactory
{
public:
    operation* createOperate(char operate){
        switch (operate)
        {
            case '+':
                return new operation_add();
                break;
            case '-':
                return new operation_sub();
                break;
            case '*':
                return new operation_mul();
                break;
            case '/':
                return new operation_div();
                break;
            default:
                std::cout<<"Please input correct operation"<<std::endl;
                break;
        }
    }
};

int main(int argc, char** argv)
{
    operationFactory factory;
    operation* oper=factory.createOperate('*');
    oper->Number_a(3);
    oper->Number_b(2);
    double result=oper->getResult();
    cout<<result<<endl;
    return 0;
}

简单工厂模式在每次增加新的车型时，需要修改工厂类，这就违反了开放封闭原则：软件实体（类、模块、函数）可以扩展，但是不可修改。于是，工厂方法模式出现了。

工厂方法模式

在这里插入图片描述

建立一个汽车抽象类和工厂抽象类
具体的汽车类型继承自汽车抽象类，如宝马、奔驰
具体生产某种汽车的工厂继承自工厂抽象类，如生产宝马的工厂、生产奔驰的共产

#include <iostream>
using namespace std;
class Car//车类
{
public:
    virtual void createdCar(void) = 0;
};

class BenzCar : public Car //奔驰车
{
public:
    BenzCar()
    {
        cout<<"Benz::Benz()"<<endl;
    }
    virtual void createdCar(void)
    {
        cout<<"BenzCar::createdCar()"<<endl;
    }
    ~BenzCar()
    {

    }
};

class BmwCar : public Car //宝马车
{
public:
    BmwCar()
    {
        cout<<"Bmw::Bmw()"<<endl;
    }
    virtual void createdCar(void)
    {
        cout<<"BmwCar::createdCar()"<<endl;
    }
};

class Factory//车厂
{
public:
    virtual Car* createSpecificCar(void) = 0;
};

class BenzFactory : public Factory//奔驰车厂
{
public:
    virtual Car* createSpecificCar(void)
    {
        return (new BenzCar());
    }
};

class BmwFactory : public Factory//宝马车厂
{
public:
    virtual Car* createSpecificCar(void)
    {
        return (new BmwCar());
    }
};

int main(int argc, char** argv)
{
    Factory* factory = new BenzFactory();
    Car* specificCarA = factory->createSpecificCar();
    factory = new BmwFactory();
    Car* specificCarB = factory->createSpecificCar();
    
    delete factory; delete specificCarA; delete specificCarB;
    
    return 0;
}

在这里插入图片描述
为此写了一个实现计算器的代码

#include <iostream>
using namespace std;
class operation //运算的抽象类
{
public:
    double number_a=0;
    double number_b=0;
public:
    void Number_a(double a){number_a=a;}
    void Number_b(double b){number_b=b;}
    virtual double getResult(){
        return 0;
    }
};
class operation_add:public operation // 加法
{
public:
    virtual double getResult(){
        double result=number_a+number_b;
        return result;
    }
};
class operation_sub:public operation // 减法
{
public:
    virtual double getResult(){
        double result=number_a-number_b;
        return result;
    }
};
class operation_mul:public operation // 乘法
{
public:
    virtual double getResult(){
        double result=number_a*number_b;
        return result;
    }
};
class operation_div:public operation // 除法
{
public:
    virtual double getResult(){
        if(abs(number_b)<1e-7){
            std::cout<<"divisor == 0"<<std::endl;
            return 0;
        }
        double result=number_a/number_b;
        return result;
    }
};

class operationFactory
{
public:
    virtual operation* createOperate(){}
};
class addFactory:public operationFactory
{
public:
    virtual operation* createOperate(){return new operation_add();}
};
class subFactory:public operationFactory
{
public:
    virtual operation* createOperate(){return new operation_sub();}
};
class mulFactory:public operationFactory
{
public:
    virtual operation* createOperate(){return new operation_mul();}
};
class divFactory:public operationFactory
{
public:
    virtual operation* createOperate(){return new operation_div();}
};

int main(int argc, char** argv)
{
    operationFactory* factory = new addFactory();
    operation* oper=factory->createOperate();
    oper->Number_a(3);
    oper->Number_b(2);
    double result=oper->getResult();
    cout<<result<<endl;
return 0;
}

抽象工厂模式

在上面的工厂方法模式基础上，有需要生产高配版的奔驰和宝马，那工厂方法模式就有点鞭长莫及了，这就又有抽象工厂模式，UML类图如下：
在这里插入图片描述

#include <iostream>
using namespace std;
class Car//车类
{
public:
    virtual void createdCar(void) = 0;
};

class BenzCar : public Car //奔驰车
{
public:
    BenzCar()
    {
        cout<<"Benz::Benz()"<<endl;
    }
    virtual void createdCar(void)
    {
        cout<<"BenzCar::createdCar()"<<endl;
    }
    ~BenzCar()
    {

    }
};

class BmwCar : public Car //宝马车
{
public:
    BmwCar()
    {
        cout<<"Bmw::Bmw()"<<endl;
    }
    virtual void createdCar(void)
    {
        cout<<"BmwCar::createdCar()"<<endl;
    }
};

class HighCar //高配版车型
{
public:
    virtual void createdCar(void) = 0;
};

class HighBenzCar : public HighCar //高配奔驰车
{
public:
    HighBenzCar()
    {
        cout<<"HighBenzCarBenz::Benz()"<<endl;
    }
    virtual void createdCar(void)
    {
        cout<<"HighBenzCar::createdCar()"<<endl;
    }
};

class HighBmwCar : public HighCar //高配宝马车
{
public:
    HighBmwCar()
    {
        cout<<"HighBmwCar::Bmw()"<<endl;
    }
    virtual void createdCar(void)
    {
        cout<<"HighBmwCar::createdCar()"<<endl;
    }
};

class Factory//车厂
{
public:
    virtual Car* createSpecificCar(void) = 0;
    virtual HighCar* createdSpecificHighCar(void) = 0;
};

class BenzFactory : public Factory//奔驰车厂
{
public:
    virtual Car* createSpecificCar(void)
    {
        return (new BenzCar());
    }

    virtual HighCar* createdSpecificHighCar(void)
    {
        return (new HighBenzCar());
    }
};

class BmwFactory : public Factory//宝马车厂
{
public:
    virtual Car* createSpecificCar(void)
    {
        return (new BmwCar());
    }
    virtual HighCar* createdSpecificHighCar(void)
    {
        return (new HighBmwCar());
    }
};

int main(int argc, char** argv)
{
    Factory* factory = new BenzFactory();
    Car* specificCar = factory->createSpecificCar();
    HighCar* spcificHighCar = factory->createdSpecificHighCar();
    
    delete factory; delete specificCar; delete spcificHighCar;
    
    return 0;
}

在这里插入图片描述
觉得写的不错的小伙伴，可以点一个赞哦，多谢！
其他设计模式将在陆续更新中

weixin_43528058
关注
专栏目录
经典软件架构设计模式
魏小言的博客
03-17 4163
—1— 分层模式（Layered Pattern (n-tier)） 分层架构模式是最常见的模式之一。分层模式背后的理念是，具有相同功能的组件将被组织成水平层。因此，每一层在应用程序中都扮演着特定的角色。 在这种模式中，我们对应用程序可以拥有的层数没有限制。在这方面，我们还提倡关注点分离的概念。分层模式风格抽象了整个软件的视图；同时提供足够的细节，以了解各个层的角色和职责以及它们之间的关系。分层模式的典型实现如下： UI展示层（UI/Presentation Layer）：渲染并运行用...
经典设计模式实战演练
GitChat
07-03 6265
课程简介 面向对象的程序应该具有可维护性，代码可复用性，扩展性以及灵活性。为了实现以上目的，前辈们从实践中总结出了一套可套用的武功招式，这就是设计模式。使用设计模式可以让你写出一手令人赏心悦目的代码。 我认为每一个后端开发者都应该学习设计模式，它是代码的精华，是程序发展的强力支撑，是能够让你发出惊叹的神来之笔。 本课程共有10篇，结合作者的开发经验，从理论到实战，剖析设计模式经典案例，帮助读者掌握...
设计模式学习笔记：工厂模式（Factory）
爱辰
07-14 876
一、工厂模式介绍 工厂模式属于设计模式中的创建型模式。工厂模式提供了一种最佳的创建对象的方式。工厂模式从简单到复杂有三种：简单工厂、工厂方法、抽象工厂。 三种工厂模式的简单区分： 简单工厂：根据传递给工厂类的不同参数创建不同的产品。例如：给生产汽车的工厂传递不同的参数生
设计模式之三种工厂模式（最易理解版）
qq_34701838的博客
07-27 379
刚刚学设计模式，不知道理解是否正确，应该有很多不对的地方，请大家指点。 简单工厂模式 问题背景 大众集团要生产汽车，但是不确定要生产哪几个品牌的汽车。 角色扮演 车： VwCar 类、AudiCar 类 工厂： Factory 类 客户端：需要去实例化车的人或者其它代码 适用场景 要生产的产品的数目和类型未知的时候。例如你的项目经理今天突然说："需要实现一个导出为 PDF 的的功能"。 实现 车 class VwCar { } class AudiCar { } 工厂 class Factory
设计模式之三种工厂模式
学习、分享
12-04 660
设计模式之三种工厂模式
设计模式（一）
weixin_40741512的博客
01-09 293
设计模式-工厂模式
经典设计模式的应用场景及类图设计
qq_51447436的博客
05-30 8439
经典设计模式的应用场景及类图设计
软件设计模式（7种）
zs980428的博客
07-11 2534
是一套被反复使用、多数人知晓的、代码设计经验的总结。它描述了在软件设计过程中的一些不断重复发生的问题，以及该问题的解决方案。也就是说，它是解决特定问题的一系列套路，是前辈们的代码设计经验的总结，具有一定的普遍性，可以反复使用。
一文快速理解23种经典设计模式
July的博客
10-20 3604
> 对经典的23种设计模式介绍，来判断适合哪种设计模式进行设计 23种设计模式： 第1 部分　适应设计模式 Iterator 模式 迭代器，松耦合 Adapter 模式 适配器模式，使用同样的类，提高复用性，提供不同的API，像电压220到5V需要充电器（适配器） 第2 部分　交给子类 Template Method 模式——将具体处理交给子类 ..
软件设计23种设计模式
养乐多要吸管
11-23 2686
软件设计23种设计模式
Java 经典设计模式讲解以及项目实战
06-14
Java 经典设计模式讲解以及项目实战 设计模式简介：主要介绍各种设计模式的概念和运用场景等 设计模式综合运用：主要是笔者在实际工作中运用到的一些设计模式综合运用事例的提炼 Spring设计模式简介：主要是讲述...
java经典设计模式（中文版）
03-28
《Java经典设计模式》中文版是一本深入浅出地介绍设计模式的书籍，它以Head First的方式呈现，使得复杂的概念变得生动易懂。设计模式是软件工程中的宝贵经验总结，是解决常见问题的有效模板，可以帮助开发者写出更...
23种经典设计模式UML类图汇总.chm_23种经典设计模式UML类图汇总.chm_uml_
09-29
《23种经典设计模式UML类图汇总》是一个关于设计模式与UML结合使用的参考资料，主要涵盖了GOF（GoF， Gamma, Helm, Johnson, Vlissides四位作者）提出的23种设计模式。 这23种设计模式可以分为三大类别：创建型模式...
java经典设计模式
05-19
Java设计模式是软件开发中的重要概念，它是一种在特定情境下解决常见问题的模板或蓝图。这些模式在软件工程中被广泛使用，因为它们代表了最佳实践，可以帮助开发者编写更可维护、可扩展和可复用的代码。下面将详细...
C++ STL中sort函数
最新发布
weixin_43349440的博客
09-15 331
刷题中经常遇到，用于各种元素排序，可以自定义排序方式，vector、deque适用。详细讲解：https://zhuanlan.zhihu.com/p/36274119。，为避免QuickSort快排的递归调用带来过大的额外负荷，就改用。一旦分段后的数据量小于某个门槛。STL的sort算法，
C语言 12 函数
天河有尽后为涯，星海无边前作岸。
09-13 1131
程序的入口点就是main函数，只需要将程序代码编写到主函数中就可以运行了，不过这个函数只是由我们来定义，而不是我们来调用。当然，除了主函数之外，一直在使用的printf那么，函数的具体定义是什么呢？函数是完成特定任务的独立程序代码单元。每次要做这个任务时，都要完完整整地将任务的每一行代码都写下来，如果程序中多处都需要执行这个任务，每个地方都完整地写一遍，实在是太臃肿了，有没有一种更好的办法能优化代码呢？
C++与QML的数据交互
qq_50679120的博客
09-11 543
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
CF C. Nikita and LCM
qq_74190237的博客
09-13 289
思维题.首先先对数组排序,考虑一种特殊情况,那就是如果数组最大值不能被其他数整除,这代表什么?代表其他数里面有某个质因子,最大值里面没有或者数量不管,所有最小公倍数都会大于最大值.那么其他情况的话,就可以确定所有的数都是最大数的因子,那么形成的最小公倍数也一定是最大数的因子,那么就可以枚举一下最大数的因子,就可以了.给长度为n的数组,求出最长的特殊子数组,如果子数组的最小公倍数不在原数组中,那么就是特殊的.
Java编程必备：23种经典设计模式详解
本文档详细介绍了Java中的23种经典设计模式，这些模式分为三大类别：创建型模式、结构型模式和行为型模式。 1. **创建型模式**： - **工厂方法模式**：该模式定义了一个创建对象的接口，让子类决定具体创建哪个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值