结构型设计模式

最新推荐文章于 2024-08-07 15:45:00 发布
最新推荐文章于 2024-08-07 15:45:00 发布
阅读量103 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29798479/article/details/126242687
版权

单例模式

        保证一个类只有一个实例，并提供一个该实列的全局访问点

        饿汉模式，懒汉模式

        使用c++11 的magic static模式，防止memory reorder

/ c++11 magic static 特性：如果当变量在初始化的时候，并发同时进⼊声明语句，并发线程将
会阻塞等待初始化结束。
// c++ effective
class Singleton
{
public:
static Singleton& GetInstance() {
static Singleton instance;
return instance;
}
private:
Singleton(){}
~Singleton() {}
Singleton(const Singleton&) {}
Singleton& operator=(const Singleton&) {}
};
// 继承 Singleton
// g++ Singleton.cpp -o singleton -std=c++11
/*该版本具备 版本5 所有优点：
1. 利⽤静态局部变量特性，延迟加载；
2. 利⽤静态局部变量特性，系统⾃动回收内存，⾃动调⽤析构函数；
3. 静态局部变量初始化时，没有 new 操作带来的cpu指令reorder操作；
4. c++11 静态局部变量初始化时，具备线程安全；
*/

   使用封裝使得singleton更加易用

template <typename T>
class Singleton5
{
public:
    static T &GetInstance()
    {
        static T instance; // 这⾥要初始化DesignPattern，需要调⽤DesignPattern
        //构造函数，同时会调⽤⽗类的构造函数。
        return instance;
    }

protected:
    virtual ~Singleton5() {}
    Singleton5() {} // protected修饰构造函数，才能让别⼈继承
    Singleton5(const Singleton &) {}
    Singleton5 &operator=(const Singleton5 &) {}
};
class DesignPattern : public Singleton5<DesignPattern>
{
friend class Singleton5<DesignPattern>; // friend 能让Singleton<T> 访问到DesignPattern构造函数 
public: ~DesignPattern() {}

private:
    DesignPattern() {}
    DesignPattern(const DesignPattern &) {}
    DesignPattern &operator=(const DesignPattern &) {}
};

工厂模式 

定义：定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使得一个类的实例化延迟到子类

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

要点：解决创建过程比较复杂，希望对外隐藏这些细节

          如：连接池，线程池

          隐藏对象的真实类型

          隐藏对象复杂的依赖关系

          隐藏对象的很多参数 

本质：延迟到子类来解决

代码

#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 IExportFactory {
public:
    IExportFactory() {
        _export = nullptr;
    }
    virtual ~IExportFactory() {
        if (_export) {
            delete _export;
            _export = nullptr;
        }
    }
    bool Export(const std::string &data) {
        if (_export == nullptr) {
            _export = NewExport();
        }
        return _export->Export(data);
    }
protected:
    virtual IExport * NewExport(/* ... */) = 0;
private:
    IExport* _export;
};

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

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

int main () {
    IExportFactory *factory = new ExportTxtFactory();
    factory->Export("hello world");
    return 0;
}

个人理解图示

 

抽象工厂 

        提供一个接口，该接口负责创建一系列相关或者相互依赖的对象，无需指定具体的类

        理解：工厂方法 + 依赖性相关性

责任链模式

定义： 多个对象都有机会处理请求，从而避免请求的发送者和接收者的耦合关系，将这些对象连成一条链，沿着这条链传递，直到有一个对象处理他为止

背景：  请假流程：一天主程批准，3天内项目经理批准，3天以上boss批准

要点：     解耦请求方和处理方  

#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 * h1 = new HandleByMainProgram();
    // IHandler * h2 = new HandleByProjMgr();
    // IHandler * h3 = new HandleByBoss();
    // h1->SetNextHandler(h2);
    // h2->SetNextHandler(h3);
// 抽象工厂
// nginx http 处理 
    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;
}

装饰器    

定义： 动态的给一个对象一些额外的功能，就增加功能而言，装饰器比生产子类更加灵活

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

本质：自己套自己的指针，每个的方法都不同

代码   

#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);
}

  

c++终结者
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最常用的设计模式---外观模式（C++实现）
黄花寒
01-09 3172
外观模式：提供了一个统一的接口，用来访问子系统的一群接口。外观定义了一个高层接口，让子系统更容易使用。目地：让接口变得简单，是为了简化子系统的接口。
c++设计模式-结构型模式
weixin_43754049的博客
07-20 455
代理模式的定义为其他对象提供了一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。在生活中代理模式的例子有很多比如我们想要访问外网youtube但是无法直接访问就需要用到代理服务器或者说当很多很同时向一个网页发起请求的时候会变得很卡这时候可以在中间设置一个代理服务器处理延迟初始化和缓存查询结果的工作输出结果用户名和密码正确，验证通过系统启动用户名或密码错误权限不足。......
C++ 设计模式 -- 结构型模式
深入浅出讲透复杂深奥的问题
05-21 332
结构型模式(Structural Pattern)：描述如何将类或者对象结合在一起形成更大的结构，就像搭积木，可以通过简单积木的组合形成复杂的、功能更为强大的结构。 类结构型模式 关心类的组合，由多个类可以组合成一个更大的系统，在类结构型模式中一般只存在继承关系和实现关系。 对象结构型模式 关心类与对象的组合，根据“合成复用原则”，在系统中尽量使用关联关系来替代继承关系，因此大部分结构型模式都是对象结构型模式。 ...
c++设计模式详解_结构型设计模式
weixin_46935110的博客
07-20 593
c++设计模式详解_结构型设计模式
4.C++设计模式-结构型模型
weixin_42636062的博客
08-27 1656
4.C++设计模式-结构型模型 让类和类进行组合，获得更大的结构。 4.1 代理模式 4.1.1 代理模式的理论 代理模式的定义：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。 举例： 比如这里面服务器B的test可能还没写好，A访问不了，先访问代理类，写好了代替再代替访问 4.1.2 代理模式的案例 传统方法局限：是个人都能调用 #include <iostream> usin
设计模式(C++)结构型简介
qq_17347313的博客
03-30 223
适配器模式 使得接口不一致的类可以一起工作 Adapter.h： #pragma once #include <string> using namespace std; namespace DesignMode { enum TransType { TCP_TRANS = 0, UDP_TRANS, }; class TCP { public: void...
设计模式之结构型模式
12-15
在本文中，我们将深入探讨结构型设计模式，特别是桥接模式、适配器模式、装饰者模式和组合模式，以及它们在实际场景中的应用。 1. **桥接模式**： 桥接模式将抽象部分与实现部分分离，使得它们可以独立进行变化。...
结构型设计模式（7种）
05-18
结构型设计模式是软件设计中的一种重要思想，它主要关注如何组织类和对象来形成更大的结构，同时保持代码的灵活性、可复用性和可维护性。在Java等面向对象编程语言中，结构型设计模式扮演着至关重要的角色。以下是7...
设计模式结构型模式
01-27
在本文中，我们将深入探讨五种结构型设计模式：适配器模式、桥接模式、组合模式、装饰模式和外观模式。 1. **适配器模式**：适配器模式允许两个不兼容的接口协同工作。适配器模式主要有三种形式：对象适配器、类...
Java设计模式代码案例 (二)：结构型设计模式.pdf
11-18
Java设计模式代码案例（二）：结构型设计模式 Java设计模式代码案例（二）：结构型设计模式主要介绍了结构型设计模式，包括适配器模式、桥接模式、组合模式、装饰模式、外观模式等。这些模式都是为了解决接口不匹配...
c++设计模式之组合模式
bbs375的博客
07-25 1767
组合模式(Composite Pattern)-结构型 意图：组合模式，将对象组合成树形结构以表示“部分-整体”的层次结构，组合模式使得用户对单个对象和组合对象的使用具有一致性。 举例：组合模式让你可以优化处理递归或分级数据结构。有许多关于分级数据结构的例子，使得组合模式非常有用武之地。 例如计算机的文件系统，文件系统由目录和文件组成。每个目录下可以有文件或是目录。目录的内容可以是文
23种设计模式：现代C++实现 V2.0
C++ 爱好者 make_it_simple888
03-16 7629
适配器模式Adapter 意图：接一个类的接口转换为客户希望的另一个接口。 例子：用deque实现栈或者队列 桥接模式Bridge 意图：将抽象部分与实现部分分离，使它们都可以独立的变化。（核心在抽象，为了应对变更才有了不同的实现） 例子：Windows各种窗口使用成员指针来指向具体的实现类 示例代码 代理模式Proxy 意图：为对象提供一种代理以控制对这个对象的访问。（核心是被代
Java经典设计模式之七大结构型模式（附实例和详解）
weixin_30535043的博客
03-07 1344
博主在大三的时候有上过设计模式这一门课，但是当时很多都基本没有听懂，重点是也没有细听，因为觉得没什么卵用，硬是要搞那么复杂干嘛。因此设计模式建议工作半年以上的猿友阅读起来才会理解的比较深刻。当然，你没事做看看也是没有坏处的。 总体来说设计模式分为三大类：创建型模式、结构型模式和行为型模式。 博主的上一篇文章已经提到过创建型模式，此外该文章还有设计模式概况和设计模式的六大原则...
单例模式（singleton）
pmc0_0的博客
07-02 150
文章目录单例模式解释形式饿汉式（静态常量）优点缺点饿汉式（静态代码块）优缺点和上面一样懒汉式（线程不安全）优点缺点懒汉式（线程安全，同步方法）优缺点分析懒汉式（线程安全，同步代码块）结论双重检查优点静态内部类优点枚举优点使用场景 单例模式 解释 单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法(静态方法)。 形式 饿汉式（静态常量） 饿汉式（静态代码块） 懒汉式（线程不安全） 懒汉式（线程安全，同步方法） 懒汉式（线程安全，同
你以为你会写单例 其实你不会 完美单例的实现
qq_16401691的博客
06-03 89
完美单例
Design Pattern - Singleton Pattern (设计模式 - 单例模式)
YtdxYHZ的专栏
04-23 597
什么是单例模式？我们只允许某个类存在唯一的一个实例 - 换句话说，对于某个类我们只new 一次为什么使用单例？比如线程池, Metrics Object, 或者Logging Object etc.  单例可以用来减少对资源的损耗，因为对于相同目的操作我们应该尽可能的重用而不是重建。如何使用单例？方法一package Chap5SingletonPattern; public class Sin...
设计模式之备忘录模式
最新发布
yimeixiaolangzai的博客
08-07 535
备忘录模式提供了一种方式，使得对象能保存其当前状态，并在未来某个时刻恢复到这个状态。这种模式通过使用三个关键组件实现：发起人（Originator）、备忘录（Memento）和看护者（Caretaker）。备忘录模式是一种非常有用的设计模式，它可以帮助我们有效地保存和恢复对象的状态，而不破坏对象的封装性。通过实践和应用备忘录模式，开发者可以更容易地实现如撤销功能这类需求，增强用户体验和系统的可靠性。在设计需要状态恢复功能的系统时，备忘录模式无疑是一个值得考虑的选择。
Spring Boot 常用设计模式
萧曳丶
08-06 602
在Spring Boot中，常用的设计模式多种多样，这些设计模式不仅帮助维护了代码的清晰度和灵活性，还使得框架易于扩展和维护。
设计模式19-状态模式
qq_41810539的博客
08-06 875
在组建构建过程中，某些对象的状态经常面临着变化。如何对这些变化进行有效的管理呢？同时又wage高层模块的稳定。状态变化模式为这一问题提供了一种解决方案。典型模式StateMemento状态模式允许对象在内部状态改变时改变其行为，对象看起来好像修改了它的类。状态模式通过将状态相关的行为封装在独立的状态类中，使得对象在不同状态下具有不同的行为，简化了状态转换的逻辑，并提高了系统的可维护性和可扩展性。在适当的场景下使用状态模式，可以显著改善代码的可读性和灵活性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值