C++面向对象基础：设计模式（下）

最新推荐文章于 2024-10-12 22:47:18 发布
最新推荐文章于 2024-10-12 22:47:18 发布
阅读量798 收藏 22
点赞数 20
分类专栏： C++基础知识 文章标签： c++ 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_73143395/article/details/136211492
版权
本文详细介绍了工厂方法、抽象工厂、责任链和装饰器模式在实际编程中的应用示例，展示了如何通过这些设计模式创建灵活、可扩展的代码结构，如数据导出选择、多级审批流程和奖金计算逻辑的定制。
摘要由CSDN通过智能技术生成

设计模式（下）

工厂方法模式

定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使得一个类的实例
化延迟到子类。 ——《设计模式》

工厂方法用于创建一个导出同类且拥有相同职责对象的接口， 用于创建过程比较复杂并且希望隐藏这些创建细节的情况下。

示例需求

实现一个导出数据的接口，让客户选择数据的导出方式；

#include <string>
// 实现导出数据的接口, 导出数据的格式包含 xml，json，文本格式txt 后面可能扩展excel格式csv
class IExport {
public:
    virtual bool Export(const std::string &data) = 0;
    virtual ~IExport(){}
};

class ExportXml : public IExport {
public:
    virtual bool Export(const std::string &data) {
        return true;
    }
};

class ExportJson : public IExport {
public:
    virtual bool Export(const std::string &data) {
        return true;
    }
};

class ExportTxt : public IExport {
public:
    virtual bool Export(const std::string &data) {
        return true;
    }
};

class IExportFactory {
public:
    virtual IExport * NewExport(/* ... */) = 0;
};

class ExportXmlFactory : public IExportFactory {
public:
    IExport * NewExport(/* ... */) {
        // 可能有其它操作，或者许多参数
        IExport * temp = new ExportXml;
        // 可能之后有什么操作
        return temp;
    }
};

class ExportJsonFactory : public IExportFactory {
public:
    IExport * NewExport(/* ... */) {
        // 可能有其它操作，或者许多参数
        IExport * temp = new ExportJson;
        // 可能之后有什么操作
        return temp;
    }
};

class ExportTxtFactory : public IExportFactory {
public:
    IExport * NewExport(/* ... */) {
        // 可能有其它操作，或者许多参数
        IExport * temp = new ExportTxt;
        // 可能之后有什么操作
        return temp;
    }
};

class ExportData {
public:
    ExportData(IExportFactory *factory) : _factory(factory) {}
    ~ExportData() {
        if (_factory) {
            delete _factory;
            _factory = nullptr;
        }
    }
    bool Export(const std::string &data) { // 稳定的流程 往基类放 
        IExport * e = _factory->NewExport();
        e->Export(data);
    }
private:
    IExportFactory *_factory;
};

int main() {
    ExportData ed(new ExportTxtFactory);
    ed.Export("hello world");
    return 0;
}

代码解释：上述代码中，如果我们希望创建ExportXm， ExportJson或者ExportTxt类的对象并使用其Export方法，我们可以创建一个其对应的工厂类实例并用于初始化总工厂ExportData对象，然后就可以通过ExportData实例来使用你需要的类的方法。当ExportXm， ExportJson或者ExportTxt的创建非常复杂时，这样做可以为客户调用接口减轻负担，同时隐藏创建的细节。注意：这个示例代码中还使用了模板方法模式。

代码结构

为每一个子类建立一个对应的工厂子类，这些工厂子类实现同一个抽象工厂接口。

抽象工厂模式

提供一个接口，让该接口负责创建一系列“相关或者相互依赖的对象”，无需指定它们具体的类。
——《设计模式》

抽象工厂是工厂方法模式的一种变种，为了缩减工厂实现子类的数量，不必给每一个产品分配一个工厂类，可以将产品进行分组，每组中的不同产品由同一个工厂类的不同方法来创建。

示例需求

实现一个拥有导出导入数据的接口，让客户选择数据的导出导入方式

#include <string>
// 实现导出数据的接口, 导出数据的格式包含 xml，json，文本格式txt 后面可能扩展excel格式csv
class IExport {
public:
    virtual bool Export(const std::string &data) = 0;
    virtual ~IExport(){}
};

class ExportXml : public IExport {
public:
    virtual bool Export(const std::string &data) {
        return true;
    }
};

class ExportJson : public IExport {
public:
    virtual bool Export(const std::string &data) {
        return true;
    }
};

class ExportTxt : public IExport {
public:
    virtual bool Export(const std::string &data) {
        return true;
    }
};

class ExportCSV : public IExport {
public:
    virtual bool Export(const std::string &data) {
        return true;
    }
};

class IImport {
public:
    virtual bool Import(const std::string &data) = 0;
    virtual ~IImport(){}
};

class ImportXml : public IImport {
public:
    virtual bool Import(const std::string &data) {
        return true;
    }
};

class ImportJson : public IImport {
public:
    virtual bool Import(const std::string &data) {
        return true;
    }
};

class ImportTxt : public IImport {
public:
    virtual bool Import(const std::string &data) {
        return true;
    }
};

class ImportCSV : public IImport {
public:
    virtual bool Import(const std::string &data) {
        // ....
        return true;
    }
};

class IDataApiFactory {
public:
    IDataApiFactory() {
        _export = nullptr;
        _import = nullptr;
    }
    virtual ~IDataApiFactory() {
        if (_export) {
            delete _export;
            _export = nullptr;
        }
        if (_import) {
            delete _import;
            _import = nullptr;
        }
    }
    bool Export(const std::string &data) {
        if (_export == nullptr) {
            _export = NewExport();
        }
        return _export->Export(data);
    }
    bool Import(const std::string &data) {
        if (_import == nullptr) {
            _import = NewImport();
        }
        return _import->Import(data);
    }
protected:
    virtual IExport * NewExport(/* ... */) = 0;
    virtual IImport * NewImport(/* ... */) = 0;
private:
    IExport *_export;
    IImport *_import;
};

class XmlApiFactory : public IDataApiFactory {
protected:
    virtual IExport * NewExport(/* ... */) {
        // 可能有其它操作，或者许多参数
        IExport * temp = new ExportXml;
        // 可能之后有什么操作
        return temp;
    }
    virtual IImport * NewImport(/* ... */) {
        // 可能有其它操作，或者许多参数
        IImport * temp = new ImportXml;
        // 可能之后有什么操作
        return temp;
    }
};

class JsonApiFactory : public IDataApiFactory {
protected:
    virtual IExport * NewExport(/* ... */) {
        // 可能有其它操作，或者许多参数
        IExport * temp = new ExportJson;
        // 可能之后有什么操作
        return temp;
    }
    virtual IImport * NewImport(/* ... */) {
        // 可能有其它操作，或者许多参数
        IImport * temp = new ImportJson;
        // 可能之后有什么操作
        return temp;
    }
};
class TxtApiFactory : public IDataApiFactory {
protected:
    virtual IExport * NewExport(/* ... */) {
        // 可能有其它操作，或者许多参数
        IExport * temp = new ExportTxt;
        // 可能之后有什么操作
        return temp;
    }
    virtual IImport * NewImport(/* ... */) {
        // 可能有其它操作，或者许多参数
        IImport * temp = new ImportTxt;
        // 可能之后有什么操作
        return temp;
    }
};

class CSVApiFactory : public IDataApiFactory {
protected:
    virtual IExport * NewExport(/* ... */) {
        // 可能有其它操作，或者许多参数
        IExport * temp = new ExportCSV;
        // 可能之后有什么操作
        return temp;
    }
    virtual IImport * NewImport(/* ... */) {
        // 可能有其它操作，或者许多参数
        IImport * temp = new ImportCSV;
        // 可能之后有什么操作
        return temp;
    }
};

// 相关性  依赖性    工作当中
int main () {
    IDataApiFactory *factory = new CSVApiFactory();
    factory->Import("hello world");
    factory->Export("hello world");
    return 0;
}

相比于普通工厂，这里把工厂分为了Xml， Txt， Json，CSV几类，每一类的对象使用同一工厂进行创建，比如TxtImport和TxtExport用同一个工厂创建出来。极大的缩减了工厂的数量。

责任链

使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。 ——《设计模式》

责任链用于实现这样的情况，有一个发送者和多个接收者，使用责任链可以把接收者串成一条链，接收者们按照顺序去处理发送的信息，且处理流程可以打断。

示例需求

请求流程，1 天内需要主程序批准，3 天内需要项目经理批准，3 天以上需要老板批准；

#include <string>

class Context {
public:
    std::string name;
    int day;
};

class IHandler {
public:
    virtual ~IHandler() {}
    void SetNextHandler(IHandler *_next) { // 链表关系
        next = _next;
    }
    // 抽象稳定点，对扩展开放
    // 模板模式：固定算法骨架，通过子类去扩展子流程
    bool Handle(const Context &ctx) {
        if (CanHandle(ctx)) {
            return HandleRequest(ctx);
        } else if (GetNextHandler()) {		//该接收者处理完数据后，让下一个节点处理
            return GetNextHandler()->Handle(ctx);
        } else {
            // err
        }
        return false;
    }
protected:
    virtual bool HandleRequest(const Context &ctx) = 0;
    virtual bool CanHandle(const Context &ctx) =0;
    IHandler * GetNextHandler() {
        return next;
    }
private:
    IHandler *next;
};

// 能不能处理，以及怎么处理
class HandleByMainProgram : public IHandler {
protected:
    virtual bool HandleRequest(const Context &ctx){
        //
        return true;
    }
    virtual bool CanHandle(const Context &ctx) {
        //
        if (ctx.day <= 10)
            return true;
        return false;
    }
};

class HandleByProjMgr : public IHandler {
protected:
    virtual bool HandleRequest(const Context &ctx){
        //
        return true;
    }
    virtual bool CanHandle(const Context &ctx) {
        //
        if (ctx.day <= 20)
            return true;
        return false;
    }
};
class HandleByBoss : public IHandler {
protected:
    virtual bool HandleRequest(const Context &ctx){
        //
        return true;
    }
    virtual bool CanHandle(const Context &ctx) {
        //
        if (ctx.day < 30)
            return true;
        return false;
    }
};

class HandleByBeauty : public IHandler {
protected:
    virtual bool HandleRequest(const Context &ctx){
        //
        return true;
    }
    virtual bool CanHandle(const Context &ctx) {
        //
        if (ctx.day <= 3)
            return true;
        return false;
    }
};

int main() {
    IHandler * h0 = new HandleByBeauty();
    IHandler * h1 = new HandleByMainProgram();
    IHandler * h2 = new HandleByProjMgr();
    IHandler * h3 = new HandleByBoss();
    h0->SetNextHandler(h1);
    h1->SetNextHandler(h2);
    h2->SetNextHandler(h3);
    // 设置下一指针 
    Context ctx;
    h0->Handle(ctx);
    
    return 0;
}

示例中我们创建的责任链由四个节点，数据会由链表上的接收者按照情况按照顺序来处理数据.同时对职责以及职责顺序运行进行抽象，那么职责变化可以任意扩展，同时职责顺序也可以任意扩展；

代码结构

  1. 从单个节点出发
  2. 每个节点实现一个条件接口和一个处理接口
  3. 构建一个链表关系

装饰器模式

动态地给一个对象增加一些额外的职责。就增加功能而言，装饰器模式比生产子类更为灵活。
—— 《设计模式》

当我们想要给一个类新增格外的职责时，继承是一种选择，但根据组合由于继承的设计原则，使用装饰器模式来扩展职责则更加灵活。注意下面的示例中，我们使用的继承并没有扩展功能，仅仅是用于重写父类的虚函数。

示例需求

普通员工有销售奖金，累计奖金，部门经理除此之外还有团队奖金；后面可能会添加环比增长奖
金，同时可能针对不同的职位产生不同的奖金组合；

#include <iostream>
// 普通员工有销售奖金，累计奖金，部门经理除此之外还有团队奖金；后面可能会添加环比增长奖金，同时可能产生不同的奖金组合；
// 销售奖金 = 当月销售额 * 4%
// 累计奖金 = 总的回款额 * 0.2%
// 部门奖金 = 团队销售额 * 1%
// 环比奖金 = (当月销售额-上月销售额) * 1%
// 销售后面的参数可能会调整
using namespace std;
class Context {
public:
    bool isMgr;
    // User user;
    // double groupsale;
};


class CalcBonus {    
public:
    CalcBonus(CalcBonus * c = nullptr) : cc(c) {}
    virtual double Calc(Context &ctx) {
        return 0.0; // 基本工资
    }
    virtual ~CalcBonus() {}

protected:
    CalcBonus* cc;		//通过组合基类
};

class CalcMonthBonus : public CalcBonus {
public:
    CalcMonthBonus(CalcBonus * c) : CalcBonus(c) {}
    virtual double Calc(Context &ctx) {
        double mbonus /*= 计算流程忽略*/; 
        return mbonus + cc->Calc(ctx);
    }
};

class CalcSumBonus : public CalcBonus {
public:
    CalcSumBonus(CalcBonus * c) : CalcBonus(c) {}
    virtual double Calc(Context &ctx) {
        double sbonus /*= 计算流程忽略*/; 
        return sbonus + cc->Calc(ctx);
    }
};

class CalcGroupBonus : public CalcBonus {
public:
    CalcGroupBonus(CalcBonus * c) : CalcBonus(c) {}
    virtual double Calc(Context &ctx) {
        double gbnonus /*= 计算流程忽略*/; 
        return gbnonus + cc->Calc(ctx);
    }
};

class CalcCycleBonus : public CalcBonus {
public:
    CalcCycleBonus(CalcBonus * c) : CalcBonus(c) {}
    virtual double Calc(Context &ctx) {
        double gbnonus /*= 计算流程忽略*/; 
        return gbnonus + cc->Calc(ctx);
    }
};

int main() {
    // 1. 普通员工
    Context ctx1;
    CalcBonus *base = new CalcBonus();
    CalcBonus *cb2 = new CalcSumBonus(base);
    CalcBonus *cb1 = new CalcMonthBonus(cb2);


    cb2->Calc(ctx1);
    // 2. 部门经理
    Context ctx2;
    CalcBonus *cb3 = new CalcGroupBonus(cb2);
    cb3->Calc(ctx2);
}

通过继承来重写父类的接口，再使用组合的方式来扩展功能，比如CalcBonus *cb2 = new CalcSumBonus(base); cb2对象的Calc职责就是CalcSumBonus + CalcBonus的组合职责，使用这种方式扩展了其功能。

坎坎坷坷.
关注
专栏目录
《C++ 设计模式》
青春不老，奋斗不止！
02-09 9万+
设计模式代表了最佳的实践，在面向对象的编程中被很多老鸟们反复使用。使用设计模式有很多好处：可重用代码、保证代码可靠性、使代码更易被他人理解 ......
C++设计模式：原型模式
ajbb093的博客
04-07 1163
在本案例中，如果对史莱姆的原型进行克隆，也就是分裂成不同的对象，而不同的史莱姆型号会对应着不同的技能，假设大型史莱姆是撞击，普通史莱姆是喷射，小型史莱姆是自爆，则简单地进行深克隆以及浅克隆可能会引起异常。因此，对此的解决办法便是原型模式结合状态模式使用，状态模式是指在软件构建过程中，某些对象的状态如果发生改变，其行为也会随之发生变化，使用状态模式将能允许一个对象在其内部状态发生改变时改变它的行为，从而使对象看起来似乎修改了其行为。，普通史莱姆转换成小型史莱姆，其中四只转换后的小型史莱姆共享血量（
C++ 面向对象程序设计
2201_75772333的博客
05-03 3783
在面向对象的思想中，我们把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。当然，一个应用程序会包含多个对象，通过多个对象的相互配合即可实现应用程序所需的功能，这样当应用程序功能发生变动时，只需要修改个别对象就可以了，使代码更容易维护。面向对象的程序设计思想可以帮助我们创建结构良好的，可复用的代码，更好地描述和理解真实世界的问题。封装可以隐藏对象的内部表示，只通过对象的方法暴露必要的操作和功能。这使得新类可以复用和扩展已存在的类的代码，提高了代码的复用性，并能够表达类之间的"is-a"关系。
C++设计模式的设计原则（面向对象八大设计原则）
不负AC不负卿的博客
07-10 3987
C++设计模式八大原则的讲解，面向对象八大设计原则的讲解，以简单易懂、有趣论说来讲解八大设计原则
C++面向对象
qq_41721746的博客
08-04 6827
一、引入 实现程序的目的------模拟现实 C语言：struct只有属性没有行为 struct Person { const char* _name; int _sex; int _age; void (*eat)(struct Person* per); void (*run)(struct Person* per); void (*sleep)(struct Person* per); void (*show)(struct Person*
c++面向对象程序设计入门
qq_59931372的博客
05-14 1685
想学习c++的小白看过来，带你认识对象的概念。
【愚公系列】软考中级-软件设计师 051-面向对象技术（设计模式-结构型）
热门推荐
时光隧道
01-27 6万+
设计模式是在软件设计领域中，为解决常见问题而被反复使用、被广泛认可的一种设计思想。它是一种经过实践验证的，被认为是最佳解决方案的经验总结，可以帮助开发人员快速高效地解决软件设计中的一些固有问题。每一个设计模式描述了一个在我们周围不断重复发生的问题，以及该问题的解决方案的核心。这样，你就能一次又一次地使用该方案而不必做重复劳动。设计模式的核心在于提供了相关问题的解决方案，使得人们可以更加简单方便的复用成功的设计和体系结构。特点描述在特定情况下被使用。
c++设计模式
qq_45395160的博客
09-04 1468
*你可以深入介绍几个面试中经常提到的设计模式，解释它们的作用、实现方法，并提供简单的示例代码。以下是几个常见的设计模式：3.1 单例模式（Singleton）概念： 确保一个类只有一个实例，并提供全局访问点。回答： “单例模式用于确保一个类在程序中只有一个实例，并且提供一个全局访问点来获取这个实例。它通常用于管理资源（如数据库连接、配置文件）。private:public:// 初始化静态成员3.2 工厂方法模式（Factory Method）
Modern C++ 学习笔记——C++面向对象编程
小小笑笑川的博客
07-02 982
结合三种设计模式，让你更加理解C++面向对象的特性，建议收藏~~~！！！ ModernC++学习笔记是一系列介绍现代C++新特性的文章，结合《effective modern C++》说明了如何更好的使用这些新特性。相互讨论，共同学习，不断成长
C++设计模式-面向对象程序设计要点以及封装性特点
IT1995的博客
11-17 4375
目录   1.面向对象程序设计要点 2.单使用封装性的例子   1.面向对象程序设计要点 面向对象程序设计要注意什么： 注意3点： 1.可维护性； 2.可扩展性； 3.可复用性； 4.灵活性好； 注意：要尽可能的避免重复； 要求业务逻辑与界面分离，让他们的耦合性降低。只有这样才能达到容易维护和扩展； 1.通过封装、继承、多态把程序的耦合度降低； 2.面向对象要结合设计模式使用，从而...
C++ 21种面向对象设计模式源代码.zip
01-23
面向对象设计模式是软件开发中的一种...总之，这个压缩包是学习和实践C++面向对象设计模式的宝贵资源，涵盖了从创建、组合到行为的各种设计模式，以及C++中类型转换的示例，对于提升C++编程能力和设计水平大有裨益。
设计模式：可复用面向对象软件的基础（非扫描版+高清）
03-20
总之，《设计模式：可复用面向对象软件的基础》是软件开发者不可或缺的参考资料，无论是在C++编程还是其他领域，都能从中受益。通过深入理解和应用设计模式，可以提高代码质量和开发效率，为软件工程带来显著的改进...
C++面向对象23种设计模式实现源码DesignPattern.zip
01-23
本资源“DesignPattern.zip”包含了23种经典的面向对象设计模式的C++实现源码，这对于学习和理解这些模式的原理及应用具有极大的帮助。 1. **解释器模式（Interpreter Pattern）**：解释器模式主要用于创建一个解析...
设计模式：可复用面向对象软件的基础 书和源码
08-26
《设计模式:可复用面向对象软件的基础》是引导读者走出软件设计迷宫的指路明灯，凝聚了软件开发界几十年设计经验的结晶。四位顶尖的面向对象领域专家精心 选取了最具价值的设计实践，加以分类整理和命名，并用简洁而...
《设计模式：可复用面向对象软件的基础》 中文高清版
11-23
设计模式：可复用面向对象软件的基础 中文高清版。此书是一本必看的设计模式书籍，书中实例采用c++实现。
42 C 语言 typedef：为基本数据类型、数组、指针、结构体、共用体起别名
Thanks_ks的IT探秘之旅
10-09 666
本文全面介绍了 C 语言中 typedef 的使用方法和技巧。从为基本类型如 int、unsigned char 起别名，到为结构体、共用体、指针以及数组等复杂类型起别名，都进行了详细的阐述。通过具体示例，展示了如何分开定义结构体和别名、如何在结构体定义中直接使用 typedef、如何为匿名结构体起别名等高级用法。此外，还探讨了为指针和数组类型起别名的方法，并给出了综合案例，帮助读者更好地理解和应用 typedef。
C++，STL 028（24.10.11）
Erif_Liu的博客
10-12 208
利用sort排序算法来对deque容器进行排序。
C++ 游戏开发技术选型指南
最新发布
进击的码农
10-12 582
在使用C++进行游戏开发时，选择合适的技术栈和工具链是项目成功的关键之一。我们探讨了游戏开发常用的一些引擎、示例代码的实现、性能优化及潜在问题解决方案。通过合理选择和配置，可以有效提高开发效率和产品质量。在此过程中，我深刻感受到技术的选择与应用只是成功的一部分，持续学习和思考如何创新更是推动项目成功的动力。希望这篇博客能对你的项目有所帮助，并期待你在开发过程中创造出更多技术上的创新与突破。
大话C++：第15篇 友元
whccf的博客
10-09 974
友元（Friend）是C++中的一个特殊概念，它允许一个类或函数访问另一个类的私有和保护成员。友元可以是一个函数，也可以是一个类。
C++面向对象编程：Singleton设计模式详解
本文将深入探讨C++面向对象编程中的Singleton设计模式以及相关的语法结构。Singleton模式是一种常用的设计模式，它确保一个类仅有一个实例，并提供全局访问点。在这个过程中，我们首先回顾了C++中类(class)的基本...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值