C++ ：设计模式实现

八月的雨季 最後的冰吻2024-04-20 14:29

文章目录

原则

单一职责原则

定义：

即一个类只负责一项职责

问题：

类 T 负责两个不同的职责：职责 P1，职责 P2。当由于职责 P1 需求发生改变而需

要修改类 T 时，有可能会导致原本运行正常

的职责 P2 功能发生故

解决：

将类 T 分成两个不同的类来实现。

开闭原则

定义：

如类、模块和函数应该对扩展开放，对修改关闭

问题：

在软件的生命周期内，因为变化、升级和维护等原因需要对软件原有代码进行修改

时，可能会给旧代码中引入错误，也可能会使我们不得不对整个功能进行重构，并且需

要原有代码经过重新测试

解决：

当软件需要变化时，尽量通过扩展软件实体的行为来实现变化

依赖倒置原则

定义：

高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节；细节应该依赖抽象

问题：

类 A 直接依赖类 B，假如要将类 A 改为依赖类 C，则必须通过修改类 A 的代码来达成。这种场景下，类 A 一般是高层模块，负责复杂的业务逻辑；类 B 和类 C 是低层模

块，负责基本的原子操作；假如修改类 A，会给程序带来不必要的风

解决：

将类 A 修改为依赖接口 I，类 B 和类 C 各自实现接口 I，类 A 通过接口 I 间接与类 B或者类 C 发生联系，则会大大降低修改类 A 的几率

接口隔离原则

定义：

客户端不应该依赖它不需要的接口；一个类对另一个类的依赖应该建立在最小的接口上

问题：

类 A 通过接口 I 依赖类 B，类 C 通过接口 I 依赖类 D，如果接口 I 对于类 A 和类 B来说不是最小接口，则类 B 和类 D 必须去实现他们不需要的方法

解决：

将臃肿的接口 I 拆分为独立的几个接口，类 A 和类 C 分别与他们需要的接口建立依

赖关系。也就是采用接口隔离原则

里氏替换原则

定义：

所有引用基类的地方必须能透明地使用其子类的对象，子类可以扩展父类的功能，但不能改变父类原有的功能。

问题：

当使用继承时，遵循里氏替换原则。类 B 继承类 A 时，除添加新的方法完成新增

功能 P2 外，尽量不要 shadow(遮盖)父类 A 的方法。

解决：

子类中可以增加自己特有的方法；

子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法（多态实现）

设计模式

单例模式

定义：

确保某一个类只有一个实例， 而且自行实例化并向整个系统提供这个实例
问题：

几个不同的客户对象需要引用同样的对象，你希望确保自己拥有的这种对象不超过一个
解决：

  1. 在 Singleton 中添加静态成员，初始化为NULL
  2. 添加静态成员方法，若静态成员变量为 NULL,则实始化并返回
  3. 将构造成员，设为 private 或是 protected，这样只能通过静态方法实例化

类关系图：


实现：

cpp 复制代码 
#include <iostream>
using namespace std;
class Singleton
{
public:
    static Singleton* getInstance()
    {
        if(_ins == NULL)
            _ins = new Singleton;
        return _ins;
    }
    static void releaseInstance()
    {
        if(_ins != NULL)
        {
            delete _ins;
            _ins = NULL;
        }
    }
    void run()
    {
        cout<<"test singleton"<<endl;
    }
private:
    Singleton(){}
    ~Singleton(){}
    Singleton(const Singleton &){}
    Singleton & operator=(const Singleton&){}
    static Singleton * _ins;
};
Singleton * Singleton::_ins = NULL;
int main()
{
    Singleton * ps = Singleton::getInstance();
    ps->run();
    Singleton::releaseInstance();
    return 0;
}
观察者模式

定义：

定义对象间一种一对多的依赖关系， 使得每当一个对象改变状态， 则所有依赖于它的对象都会得到通知并被自动更新，也成为发布-订阅模式
问题：

当某个事件发生变化时，你需要向一系列对象发出通知，而这个对象的列表也是不断变化的。
解决：

Observer 将监视某个事件上的责任委托给一个中心对象：Subject ，当事件发生时，Subject 告诉 Observer"你关心的事件发生了"

类关系图：

实现：

// 观察者模式实现 时间更新

cpp 复制代码 
#include <iostream>
#include <list>
#include <algorithm>
using namespace std;

// 观察者模式，又称为订阅模式 ，比如关注的公众号更新会自动发送到手机上

class Observer
{
public:
    virtual void update(int hour, int min ,int sec) = 0;
};

class Subject
{
public:
    virtual void registerObserver(Observer * ob) = 0;
    virtual void removeObserver(Observer *ob) = 0;
    virtual void notify() = 0;
protected:
    list<Observer*> observerList;
};

class PekingTimeSubject:public Subject
{
public:
    void setTimer(int hour, int min, int sec)
    {
        _hour = hour;
        _min = min;
        _sec = sec;
        notify();
    }
    void registerObserver(Observer * ob)
    {
        observerList.push_back(ob);
    }
    void removeObserver(Observer *ob)
    {
        //observerList.erase(find(observerList.begin(),observerList.end(),ob));
        observerList.remove(ob);
    }
    void notify() // 此函数必须在子类中实现，因为，要接触数据。
    {
        list<Observer*>::iterator itr = observerList.begin();
        for(; itr != observerList.end(); itr++)
        {
            (*itr)->update(_hour,_min,_sec);
        }
    }
private:
    int _hour;
    int _min;
    int _sec;
};
class AmericaTimerObserver:public Observer
{
public:
    void update(int hour, int min ,int sec)
    {
        _hour = hour;
        _min = min;
        _sec = sec;
        dis();
    }
    void dis()
    {
        cout<<"America Time is update"<<endl;
        cout<<"H:"<<_hour<<" M:"<<_min<<" S:"<<_sec<<endl;
    }
private:
    int _hour;
    int _min;
    int _sec;
};
class JapanTimerObserver:public Observer
{
public:
    void update(int hour, int min ,int sec)
    {
        _hour = hour;
        _min = min;
        _sec = sec;
        dis();
    }
    void dis()
    {
        cout<<"Japan Time is update"<<endl;
        cout<<"H:"<<_hour<<" M:"<<_min<<" S:"<<_sec<<endl;
    }
private:
    int _hour;
    int _min;
    int _sec;
};
int main()
{
    PekingTimeSubject *bj = new PekingTimeSubject;
    JapanTimerObserver *jp = new JapanTimerObserver;
    AmericaTimerObserver *am = new AmericaTimerObserver;
    bj->registerObserver(jp);
    bj->registerObserver(am);
    bj->setTimer(10,20,30);
    bj->removeObserver(jp);
    bj->setTimer(1,2,3);
    return 0;
}
策略模式

定义：

提供便利的的功能/算法切换

问题：

将变动的策略写死在，固定的代码中。不利于更改和维护

解决：

将策略抽象出来，进行封装

Strategy(策略）： 所有支持的算法的公共接口

Context(上下文)

类关系图：

实现：

// 实现游戏人物通过相同按键切换武器

cpp 复制代码 
#include <iostream>

using namespace std;

// 定义了一组算法，进行封装

class Weapon
{
public:
    virtual void use() = 0;
};

class Knife :public Weapon
{
public:
    void use()
    {
        cout<<" dao ni "<<endl;
    }
};
class Gun :public Weapon
{
public:
    void use()
    {
        cout<<" tutu ni "<<endl;
    }
};

class CCsprite
{
public:
    CCsprite(Weapon *k)
    {
        _w = k;
    }
    void changWeapon(Weapon *w)
    {
        _w = w;
    }
    void faighting()
    {
        _w->use();
    }
protected:
    Weapon *_w;
};
int main()
{
    Knife k;
    CCsprite character(&k);
    character.faighting();
    Gun g;
    character.changWeapon(&g);
    character.faighting();
    character.changWeapon(&k);
    character.faighting();
    return 0;
}
代理模式

定义：

（为其他对象

提供一种代理以控制对这个对象的访问
问题：

对一个对象进行访问控制的一个原因是为了只有在我们确实需要这个对象时才对它进行创建和初始化
解决：

对被访问的提供一个壳

Subject 抽象主题角色

ConcreteSubject 具体主题角色也叫做被委托角色、 被代理角色，是业务逻辑的具体执行者

ProxySubject 代理主题角色，负责对真实角色的应用

类关系图：

实现：

//模拟加载页面中先显示文字，后显示图片的过程

cpp 复制代码 
#include <iostream>
#include <unistd.h>
using namespace std;

// LargeImage 为自己，显示图片，需要先构造6s
// ProxyLargeImage 为它的代理，他们都继承虚基类ImageSubject，代理LargeImage调用图像
class Text
{
public:
    void showText()
    {
        cout<<"wed text is show "<<endl;
    }
};
class ImageSubject
{
public:
    virtual void showPicture() = 0;
};

class LargeImage:public ImageSubject
{
public:
    LargeImage()
    {
        sleep(6);
    }
    virtual void showPicture()
    {
        cout<<"xiang ri kui \n"<<endl;
    }
};

class ProxyLargeImage:public ImageSubject
{
public:
    ProxyLargeImage():li(NULL){}
    void showPicture()
    {
        if(li == NULL)
            li = new LargeImage;
        li->showPicture();
    }
protected:
    LargeImage *li;
};
class Document
{
public:
    Document()
    {
        _t = new Text; //1
        _i = new ProxyLargeImage; //1000
    }
    void print()
    {
        _t->showText();
        _i->showPicture();
    }
    Text *_t;
    ProxyLargeImage *_i;
};
int main(int argc, char *argv[])
{
    Document doc;
    doc.print(); // 一分部加载文件字，一部分加载图片
    return 0;
}
相关推荐
G丶AEOM6 分钟前
JVM逃逸分析机制
java·jvm
无聊写博客10 分钟前
JDK、JRE、JVM的区别
java·开发语言·jvm
黑不溜秋的11 分钟前
C++ 编程指南04 - 尽量编写静态类型安全的程序
开发语言·c++·安全
message丶小和尚33 分钟前
SpringBoot升级全纪录之项目启动
java·spring boot·mybatis
Allen Bright1 小时前
IDEA配置本地maven
java·maven·intellij-idea
努力学习的饼干1 小时前
C++模版特化和偏特化
开发语言·c++
总是学不会.1 小时前
【贪心算法】绿洲之旅：最少次数补给探索
java·算法·intellij-idea
就玩一会_1 小时前
谷粒商城-消息队列Rabbitmq
java·rabbitmq·java-rabbitmq·谷粒商城
Viktor_Ye1 小时前
实现金蝶云星空与钉钉数据无缝集成的技术方法
java·大数据·钉钉
程序员学姐1 小时前
基于SpringBoot+Vue的高校社团管理系统
java·开发语言·vue.js·spring boot·后端·mysql·spring
热门推荐
01抖音的互联网架构02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04国内外大模型汇总：Open AI大模型、Google大模型、Microsoft大模型、文心一言大模型、通义千问大模型、字节豆包大模型、智普清言大模型05Coze扣子平台完整体验和实践（附国内和国际版对比）06(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明07【凡人修仙传_01】散修厉飞羽是如何出师未捷身先死的！08玄机平台应急响应—webshell查杀09RAG 实践- Ollama+RagFlow 部署本地知识库10〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇