C++ 常见设计模式总结

最新推荐文章于 2024-06-12 13:51:17 发布
最新推荐文章于 2024-06-12 13:51:17 发布
阅读量1.7k 收藏 28
点赞数 3
分类专栏： C++后端知识 文章标签： c++ 设计模式 单例模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41952309/article/details/126475540
版权

文章目录


1.面向对象中有哪些设计原则？


2.开闭原则，哪些原则与它相关，其关系


3.里氏替换原则原则

#include <iostream>
using namespace std;

class ZooShow {
public:
    void Show() {
        if (Show0()) {
            PlayGame();
        }
        Show1();
        Show2();
        Show3();
    }

private:
    void PlayGame() {
        cout << "after Show0, then play game" << endl;
    }
    

protected:
    virtual bool Show0() {
        cout << "show0" << endl;
        if (!expired) {
            return true;
        }
        return false;
    }
    virtual void Show2() {
        cout << "show2" << endl;
    }
    virtual void Show1() {
        
    }
    virtual void Show3() {

    }
    bool expired;
};

class ZooShowEx1 : public ZooShow {
protected:
    virtual bool Show0() {
        cout << "ZooShowEx1 show0" << endl;
        if (! expired) { //里氏替换
            return true;
        }
        return false;
    }
    virtual void Show2() {

    }
};

4.迪米特原则


5.依赖倒置原则


6.单例模式多线程


单线程环境下的单例模式：

class Singleton {
public:
    static Singleton *GetInstance() {
        if (_instance == nullptr) {
            _instance = new Singleton();
            std::atexit(Destructor);
        }
        return _instance;
    }
private:
    static void Destructor() {
        if (_instance != nullptr) {
            delete _instance;
            _instance = nullptr;
        }
    }
    Singleton() {}
    ~Singleton() {}
    Singleton(const Singleton &clone) {}
    Singleton & operator = (const Singleton &) {}
    static Singleton *_instance;
};

Singleton * Singleton::_instance = nullptr;

多线程环境互斥锁

#include <mutex>

class Singleton {
public:
    static Singleton *GetInstance() {
        // std::lock_guard<std::mutex> lock(_mutex);  //加锁粒度大
        if (_instance == nullptr) {
            std::lock_guard<std::mutex> lock(_mutex);
            if (_instance == nullptr) {
                _instance = new Singleton();  //多线程环境下编译器和CPU对程序进行优化
                // 1. 分配内存
                // 2. 调用构造函数
                // 3. 返回指针，赋值运算
                // 多线程环境下可能会优化为1 3 2
                std::atexit(Destructor);
            }
        }
        return _instance;
    }
private:
    static void Destructor() {
        if (_instance != nullptr) {
            delete _instance;
            _instance = nullptr;
        }
    }
    Singleton() {}
    ~Singleton() {}
    Singleton(const Singleton &clone) {}
    Singleton & operator = (const Singleton &) {}
    static Singleton *_instance;
    static std::mutex _mutex;
};

Singleton * Singleton::_instance = nullptr;
std::mutex Singleton::_mutex;

#include <mutex>
#include <atomic>
class Singleton {
public:
    static Singleton *GetInstance() {
        Singleton *temp = _instance.load(std::memory_order_relaxed);
        std::atomic_thread_fence(std::memory_order_acquire);
        if (temp == nullptr) {
            std::lock_guard<std::mutex> lock(_mutex);
            temp = _instance.load(std::memory_order_relaxed);
            if (temp == nullptr) {
                temp = new Singleton();  //多线程环境下编译器和CPU对程序进行优化
                std::atomic_thread_fence(std::memory_order_release);
                _instance.store(temp, std::memory_order_relaxed);
                // 1. 分配内存
                // 2. 调用构造函数
                // 3. 返回指针，赋值运算
                // 多线程环境下可能会优化为1 3 2
                std::atexit(Destructor);
            }
        }
        return temp;
    }
private:
    static void Destructor() {
        Singleton *temp = _instance.load(std::memory_order_relaxed);
        if (temp != nullptr) {
            delete temp;
            temp = nullptr;
            _instance.store(temp, std::memory_order_relaxed);
        }
    }
    Singleton() {}
    ~Singleton() {}
    Singleton(const Singleton &clone) {}
    Singleton & operator = (const Singleton &) {}
    static std::atomic<Singleton *> _instance;
    static std::mutex _mutex;
};

std::atomic<Singleton *> Singleton::_instance;
std::mutex Singleton::_mutex;

7.什么是工厂模式？什么是抽象工厂？


7.1 简单工厂模式
  1. 定义：根据参数的不同返回不同类的实例，被创建的实例通常具有共同的基类。
  2. 结构：
    • 工厂：根据客户提供的具体产品类的参数，创建具体产品的实例。
    • 抽象产品：具体产品类的基类，包含创建产品的公共方法。
    • 具体产品：抽象产品的派生类，特定产品的实现方法。
  3. 优点：
    • 工厂类提供创建产品的具体方法，客户不必参与创建过程。
    • 客户只需要知道对应产品参数即可。
  4. 缺点：
    • 客户增加产品时，需要修改工厂类逻辑，违背开闭原则。
7.2 工厂方法模式
  1. 定义：工厂类中针对不同的产品设计不同的工厂，每种工厂是生成特定的产品（解决简单工厂模式存在的不足）。定义一个用于创建对象的接口，但是让子类决定将哪一个类实例化。工厂方法模式让一个类的实例化延迟到其子类。
  2. 结构：
    • 抽象工厂：所有生产具体产品的工厂类的基类，提供工厂类的公共方法。
    • 具体工厂：生产具体的产品工厂类。
    • 抽象产品：所有产品的基类，提供产品类的公共方法。
    • 具体产品：具体的产品类。
  3. 优点：
    • 工厂方法用于创建客户所需产品，同时向客户隐藏细节，用户只需关心所需产品对应的工厂；
    • 工厂自主决定创建何种产品，并且创建过程封装在具体工厂对象内部，多态性设计是工厂方法模式的关键；
    • 新加入产品时，无需修改原有代码，增强了系统的可扩展性，符合开闭原则。
  4. 缺点：
    • 添加新的产品时，引入新的产品工厂，增加了系统复杂度；
    • 工厂和产品中都引入抽象层，增加了系统的抽象层次。
7.3 抽象工厂模式
  1. 定义：一个工厂不止生产一种产品，生产一类产品。提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
  2. 结构：
    • 抽象工厂：所有生产具体产品的工厂类的基类，提供工厂类的公共方法。
    • 具体工厂：生产具体的产品工厂类，可以生产多种同类相关的产品。
    • 抽象产品：所有产品的基类，提供产品类的公共方法。
    • 具体产品：具体的产品类。
  3. 优点：
    • 工厂方法用于创建客户所需产品，同时向客户隐藏细节，用户只需关心所需产品对应的工厂；
    • 新加入产品时，无需修改原有代码，增强了系统的可扩展性，符合开闭原则。
  4. 缺点：
    • 添加新产品时需要修改抽象层代码，对原有系统改动较大。
#include <string>

// 实现导出数据的接口
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:
    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 ExoortXmlFactory : public IExportFactory {
protected:
    virtual IExport * NewExport(/*---*/) {
        // 可能有其它很多操作
        IExport * temp = new ExportXml();
        return temp;
    }
};

class ExoortJsonFactory : public IExportFactory {
protected:
    virtual IExport * NewExport(/*---*/) {
        // 可能有其它很多操作
        IExport * temp = new ExportJson();
        return temp;
    }
};

class ExoortTxtFactory : public IExportFactory {
protected:
    virtual IExport * NewExport(/*---*/) {
        // 可能有其它很多操作
        IExport * temp = new ExportTxt();
        return temp;
    }
};

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

8.什么是代理模式？应用场景是什么？


class ISsubject {
public:
    virtual void Handle() = 0;
    virtual ~ISsubject() {}
};

class RealSubject : public ISsubject {
public:
    virtual void Handle() {

    }
};
// 保护代理 
class Proxy1 : public ISsubject {
public:
    Proxy1(ISsubject * subject) : _subject(subject) {}
    virtual void Handle() {
        // 在访问RealSubject 之前一些处理
        // if (不满足条件)
        // return;
        _subject->Handle();
        count++;
        // 在访问RealSubject 之后做一些处理
    }
private:
    ISsubject * _subject;
    static int count;
};
int Proxy1::count = 0;

// 远程代理
class Proxy2 : public ISsubject {
public:
    virtual void Handle() {
        // 在访问RealSubject之前做一些特殊处理
        // 发送数据到远端 网络处理 同步非阻塞 ntyco c协程
        // IResult * val = rpc->call("RealSubject", "Handle");
        // 在访问RealSubject之后做一些处理
    }
private:
    /*void callback(IResult * val) {
        // 在访问RealSubject 之后做一些处理
    }
    */
};

// 虚代理
class Proxy3 : public ISsubject {
public:
    Proxy1(ISsubject *subject) : _subject(subject), _loaded(false) {}
    virtual void Handle() {
        if (! _loaded) {
            _loaded = true;
            //加载资源
        }
        _subject->Handle();
    }
private:
    ISsubject* _subject;
    bool _loaded;
};

9.什么是装饰器模式？应用模式是什么？

#include <iostream>

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 CalcMouthBonus : public CalcBonus {
public:
    CalcMouthBonus(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 mbonus /*计算自己的*/;
        return mbonus + cc->Calc(ctx);
    }
};

class CalcCycleBonus : public CalcBonus {
public:
    CalcCycleBonus(CalcBonus * c) : CalcBonus(c) {}
    virtual double Calc(Context &ctx) {
        double mbonus /*计算自己的*/;
        return mbonus + cc->Calc(ctx);
    }
};

int main() {
    Context ctx1;
    CalcBonus *base = new CalcBonus();
    CalcBonus *cb2 = new CalcSumBonus(base);
    CalcBonus *cb1 = new CalcMouthBonus(cb2);
    cb2->Calc(ctx1);

    return 0;
}

10.什么是组合模式？应用场景是什么？

class IComponent {
public:
    IComponent(/* args */);
    ~IComponent();
    virtual void Execute() = 0;
    virtual void AddChild(IComponent *ele) {}
    virtual void RemoveChild(IComponent *ele) {}
};

class Leaf : public IComponent {
public:
    virtual void Execute() {
        cout << "leaf execute" << endl;
    }
};

class Composite : public IComponent {
private:
    std::list<IComponent *> _list;
public:
    virtual void AddChild(IComponent *ele) {
        // 
    }
    virtual void RemoveChild(IComponent *ele) {

    }
    virtual void Execute() {
        for (auto iter = _list.begin(); iter != _list.end(); iter ++) {
            iter->Execute();
        }
    }
};

11.什么是责任链模式？应用场景是什么？


12.什么是模板方法? 应用场景是什么？


13.什么是策略模式？应用场景是什么？


14.什么是观察者模式？应用场景是什么？

参考

推荐一个零声学院免费公开课程，个人觉得老师讲得不错，分享给大家：[Linux，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，TCP/IP，协程，DPDK等技术内容，点击立即学习:https://course.0voice.com/v1/course/intro?courseId=5&agentId=0

卧栏听风
关注
  • 3
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++设计模式代码资源
08-17
这些设计模式是软件工程中的宝贵经验总结，理解和熟练运用它们能提升C++编程的效率和质量。通过学习压缩包中的代码资源，你可以更深入地理解每个模式的实现细节，以及它们在实际项目中的应用。同时，实践这些代码...
C++设计模式-单实例
01-20
设计模式是一种在特定场景下解决常见问题的模板，它基于前人的经验总结，使得代码可读性更强，也更易于重用。在C++中，单例模式的核心思想是确保一个类只有一个实例，并提供一个全局访问点来获取这个唯一的实例。 ...
C++设计模式（全23种）
热门推荐
weixin_45712636的博客
04-27 5万+
设计模式概述 设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。等这种思想融入到了思想中后，你就会不自觉地使用这种思想去进行你的设计和开发。 文章目录设计模式概述一、创建型模式Factory 模式（工厂模式）AbstactFactory 模式（抽象工厂模式）Singleton 模式（ 单例模式）Builder 模式（建造者模式）Prototype 模式（原型模式）二、结构型模式Bridge 模式（桥接模式）总结
C++设计模式总结
长期更新Java自学笔记
09-06 4457
一、单例模式 一个类不管常见多少次对象，永远只能得到该类型一个对象的实例 // p1、p2、p3指向同一对象 A* p1 = new A(); A* p2 = new A(); A* p3 = new A(); 饿汉式单例模式： 还没有获取实例对象，实例对象就已经产生了 优点：线程安全。对象存放在数据段，main函数还没有开始执行，对象就已经初始化好了，一定是线程安全的。 缺点： 获取在软件启动的时候，并没有使用到这个对象，然而这个对象已经产生，这就比较浪费资源。 #include<iostream
C++中的23种设计模式
最新发布
GOLOJO的博客
06-12 2249
C++的23种设计模式
C++几种常用设计模式
qq_46423987的博客
09-05 1万+
设计模式
c++—设计模式
m0_72814368的博客
06-05 2564
c++—设计模式
C++ 中 10 种常见设计模式实现
sinat_28305511的博客
06-08 1039
C++ 10中常见设计模式，强烈建议收藏
23种设计模式(C++).pdf
11-29
设计模式是软件工程中的宝贵经验总结，它们为解决常见问题提供了可复用的解决方案，是提升软件可维护性和扩展性的重要工具。 1. **创建型模式**： - **工厂模式**：它提供了一种创建对象的最佳方式，通过一个公共...
C++设计模式大总结
12-12
C++设计模式大总结是一个全面概述C++编程中常用设计模式的资源集合，旨在帮助学习者深入理解和应用这些模式。这个资源包含一个Visual Studio工程，方便用户进行学习、复习以及进一步的开发和改进。让我们逐一探讨...
C.C++设计模式
04-29
在软件工程领域，设计模式是一种在特定情境下解决常见问题的经验总结，是经过验证的、通用的、可重用的解决方案。"C.C++设计模式"着重探讨如何在C和C++这两种编程语言中应用这些模式，以提高代码的可读性、可维护性...
20种常见设计模式的C++实现
12-04
20种常见设计模式的C++实现-----
C++的23种设计模式
07-30
详细讲解了 编程的 23种设计模式，附带详细源码实例。
常见设计模式的解析和实现(C++)共21种.UML类图+讲解
01-23
常见设计模式的解析和实现(C++)共21种.zip
c++课程设计总结 课程设计总结
05-11
C++课程设计总结 经过一个学期对《C++程序设计》的学习，我学习到了基本的理论知识，了解到了C++语言程序设计的思想，这些知识都为我的课程实践和进一步的学习打下了坚实的基础。
23种常用设计模式（C++）
算法的实践
11-05 9279
23种常用设计模式（C++）
C++常用设计模式
蜗牛的专栏
07-23 233
常用的设计模式：工厂模式（简单工厂、工厂、抽象工厂）、观察者模式、组合模式、单例模式等
C++23种设计模式（未整理，未完待续6/11）
谢白羽
06-10 1202
文章目录 1.设计模式分类 设计模式的本质特征：封装变化 （栈队列：适配器设计模式） 1）创建型设计模式 2) 结构性设计模式 3）行为型设计模式 红色为重点 2.创建类设计模式 1） 2）工厂模式 这样不行，就放入工厂 静态工厂模式 但是还要选择，故使用枚举 静态工厂方法 缺点： 1.违反了开闭原则，扩展性受限 2.违反了单一职责原则，做的事情太多了 使用条件： 使用类型比较少的时候 要进行改造-》 纯虚类当基类 继承 加override的好处，防止写错 工厂模式：对
C++设计模式总结：继承、关联与模式原则
"这篇文章是关于C++实现的设计模式个人总结，结合了黑马视频教程的精华内容，适合面试准备。文章涵盖了类与类之间的关系，包括泛化、关联、依赖、聚合和组合，并介绍了设计模式的基本原则，如开放封闭原则和依赖倒置...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值