C++设计模式之“单一职责”模式

最新推荐文章于 2023-12-14 16:47:25 发布
最新推荐文章于 2023-12-14 16:47:25 发布
阅读量214 收藏 1
点赞数
分类专栏： C++模式设计 文章标签： 设计模式

Decorator装饰模式

“单一职责”模式：
  • 在软件组件的设计中，如果责任划分的不清楚，使用继承得到的结果往往是随着需求的变化，子类急剧膨胀，同时充斥着重复代码，这时候的关键是划清责任。
  • 典型模式
    • Decorator
    • Bridge
动机（Motivation）
  • 在某些情况下我们可能会“过度地使用继承来扩展对象的功能”，由于继承为类型引入的静态特质，使得这种扩展方式缺乏灵活性；并且随着子类的增多（扩展功能的增多），各种子类的组合（扩展功能的组合）会导致更多子类的膨胀。
  • 如何使“对象功能的扩展”能够根据需要来动态地实现？同时避免“扩展功能的增多”带来的子类膨胀问题？从而使得任何“功能扩展变化”所导致的影响降为最低？
    decorator1.cpp
//业务操作
class Stream{
public：
    virtual char Read(int number)=0;
    virtual void Seek(int position)=0;
    virtual void Write(char data)=0;
    
    virtual ~Stream(){}
};

//主体类
class FileStream: public Stream{
public:
    virtual char Read(int number){
        //读文件流
    }
    virtual void Seek(int position){
        //定位文件流
    }
    virtual void Write(char data){
        //写文件流
    }
};
class NetworkStream :public Stream{
public:
    virtual char Read(int number){
        //读网络流
    }
    virtual void Seek(int position){
        //定位网络流
    }
    virtual void Write(char data){
        //写网络流
    }
};

class MemoryStream :public Stream{
public:
    virtual char Read(int number){
        //读内存流
    }
    virtual void Seek(int position){
        //定位内存流
    }
    virtual void Write(char data){
        //写内存流
    }
    
};

//扩展操作
class CryptoFileStream :public FileStream{
public:
    virtual char Read(int number){
       
        //额外的加密操作...
        FileStream::Read(number);//读文件流
        
    }
    virtual void Seek(int position){
        //额外的加密操作...
        FileStream::Seek(position);//定位文件流
        //额外的加密操作...
    }
    virtual void Write(byte data){
        //额外的加密操作...
        FileStream::Write(data);//写文件流
        //额外的加密操作...
    }
};

class CryptoNetworkStream : :public NetworkStream{
public:
    virtual char Read(int number){
        //额外的加密操作...
        NetworkStream::Read(number);//读网络流
    }
    virtual void Seek(int position){
        //额外的加密操作...
        NetworkStream::Seek(position);//定位网络流
        //额外的加密操作...
    }
    virtual void Write(byte data){
        //额外的加密操作...
        NetworkStream::Write(data);//写网络流
        //额外的加密操作...
    }
};

class CryptoMemoryStream : public MemoryStream{
public:
    virtual char Read(int number){
        //额外的加密操作...
        MemoryStream::Read(number);//读内存流
    }
    virtual void Seek(int position){
        //额外的加密操作...
        MemoryStream::Seek(position);//定位内存流
        //额外的加密操作...
    }
    virtual void Write(byte data){
        //额外的加密操作...
        MemoryStream::Write(data);//写内存流
        //额外的加密操作...
    }
};
class BufferedFileStream : public FileStream{
    //...
};

class BufferedNetworkStream : public NetworkStream{
    //...
};
class BufferedMemoryStream : public MemoryStream{
    //...
}
class CryptoBufferedFileStream :public FileStream{
public:
    virtual char Read(int number){
        //额外的加密操作...
        //额外的缓冲操作...
        FileStream::Read(number);//读文件流
    }
    virtual void Seek(int position){
        //额外的加密操作...
        //额外的缓冲操作...
        FileStream::Seek(position);//定位文件流
        //额外的加密操作...
        //额外的缓冲操作...
    }
    virtual void Write(byte data){
        //额外的加密操作...
        //额外的缓冲操作...
        FileStream::Write(data);//写文件流
        //额外的加密操作...
        //额外的缓冲操作...
    }
};

void Process(){
        //编译时装配
    CryptoFileStream *fs1 = new CryptoFileStream();
    BufferedFileStream *fs2 = new BufferedFileStream();
    CryptoBufferedFileStream *fs3 =new CryptoBufferedFileStream();

}

在这里插入图片描述
decorator2.cpp

//业务操作
class Stream{
public：
    virtual char Read(int number)=0;
    virtual void Seek(int position)=0;
    virtual void Write(char data)=0;
    virtual ~Stream(){}
};
//主体类
class FileStream: public Stream{
public:
    virtual char Read(int number){
        //读文件流
    }
    virtual void Seek(int position){
        //定位文件流
    }
    virtual void Write(char data){
        //写文件流
    }
};
class NetworkStream :public Stream{
public:
    virtual char Read(int number){
        //读网络流
    }
    virtual void Seek(int position){
        //定位网络流
    }
    virtual void Write(char data){
        //写网络流
    }
};
class MemoryStream :public Stream{
public:
    virtual char Read(int number){
        //读内存流
    }
    virtual void Seek(int position){
        //定位内存流
    }
    virtual void Write(char data){
        //写内存流
    }
};
//扩展操作
class CryptoStream: public Stream {
    Stream* stream;//...
public:
    CryptoStream(Stream* stm):stream(stm){
    }
    virtual char Read(int number){
        //额外的加密操作...
        stream->Read(number);//读文件流
    }
    virtual void Seek(int position){
        //额外的加密操作...
        stream::Seek(position);//定位文件流
        //额外的加密操作...
    }
    virtual void Write(byte data){
        //额外的加密操作...
        stream::Write(data);//写文件流
        //额外的加密操作...
    }
};

class BufferedStream : public Stream{
    Stream* stream;//...
public:
    BufferedStream(Stream* stm):stream(stm){  
    }
    //...
};
void Process(){
    //运行时装配
    FileStream* s1=new FileStream();
    CryptoStream* s2=new CryptoStream(s1);
    BufferedStream* s3=new BufferedStream(s1);
    BufferedStream* s4=new BufferedStream(s2);
}

decorator3.cpp

//业务操作
class Stream{

public：
    virtual char Read(int number)=0;
    virtual void Seek(int position)=0;
    virtual void Write(char data)=0;
    
    virtual ~Stream(){}
};

//主体类
class FileStream: public Stream{
public:
    virtual char Read(int number){
        //读文件流
    }
    virtual void Seek(int position){
        //定位文件流
    }
    virtual void Write(char data){
        //写文件流
    }

};

class NetworkStream :public Stream{
public:
    virtual char Read(int number){
        //读网络流
    }
    virtual void Seek(int position){
        //定位网络流
    }
    virtual void Write(char data){
        //写网络流
    }
    
};

class MemoryStream :public Stream{
public:
    virtual char Read(int number){
        //读内存流
    }
    virtual void Seek(int position){
        //定位内存流
    }
    virtual void Write(char data){
        //写内存流
    }
    
};

//扩展操作

DecoratorStream: public Stream{
protected:
    Stream* stream;//...
    DecoratorStream(Stream * stm):stream(stm){
    
    }
    
};
class CryptoStream: public DecoratorStream {
public:
    CryptoStream(Stream* stm):DecoratorStream(stm){
    
    }
    
    virtual char Read(int number){
       
        //额外的加密操作...
        stream->Read(number);//读文件流
    }
    virtual void Seek(int position){
        //额外的加密操作...
        stream::Seek(position);//定位文件流
        //额外的加密操作...
    }
    virtual void Write(byte data){
        //额外的加密操作...
        stream::Write(data);//写文件流
        //额外的加密操作...
    }
};

class BufferedStream : public DecoratorStream{
    Stream* stream;//...
    
public:
    BufferedStream(Stream* stm):DecoratorStream(stm){
        
    }
    //...
};
void Process(){
    //运行时装配
    FileStream* s1=new FileStream();
    CryptoStream* s2=new CryptoStream(s1);
    BufferedStream* s3=new BufferedStream(s1);
    BufferedStream* s4=new BufferedStream(s2);
}

在这里插入图片描述

模式定义

动态（组合）地给一个对象增加一些额外的职责。就增加功能而言，Decorator模式比生成子类（继承）更为灵活（消除重复代码&减少子类个数）。 ----《设计模式》GoF

结构（Structure)

在这里插入图片描述

要点总结
  • 通过采用组合而非继承的手法，Decorator模式实现了在运行时动态扩展对象功能的能力，而且可以根据需要扩展多个功能。避免了使用继承带来的“灵活性差”和“多子类衍生问题”。
  • Decorator类在接口上表现为is-a Component的继承关系，即Decorator类继承了Component类所具有的接口。但在实现上又表现为has-a Component的组合关系，即Decorator类又使用了另外一个Component类。
  • Decorator模式的目的并非解决“多子类衍生的多继承”问题，Decorator模式应用的要点在于解决“主体类在多个方向 上的扩展功能” ----是为“装饰”的含义。

Bridge 桥模式

“单一职责”模式：
  • 在软件组件的设计中，如果责任划分的不清楚，使用继承得到的结果往往是随着需求的变化，子类急剧膨胀，同时充斥着重复代码，这时候的关键是划清责任。
  • 典型模式
    • Decorator
    • Bridge
动机（Motivation）
  • 由于某些类型的固有的实现逻辑，使得它们具有两个变化的维度，乃至多个维度的变化。
  • 如何应对这种“多维度的变化”？如何利用面向对象技术来使得类型可以轻松地沿着两个乃至多个方向变化，而不引入额外的复杂度？
    bridge1.cpp
class Messager{
public:
    virtual void Login(string username, string password)=0;
    virtual void SendMessage(string message)=0;
    virtual void SendPicture(Image image)=0;

    virtual void PlaySound()=0;
    virtual void DrawShape()=0;
    virtual void WriteText()=0;
    virtual void Connect()=0;
    
    virtual ~Messager(){}
};
//平台实现
class PCMessagerBase : public Messager{
public:
    virtual void PlaySound(){
        //**********
    }
    virtual void DrawShape(){
        //**********
    }
    virtual void WriteText(){
        //**********
    }
    virtual void Connect(){
        //**********
    }
};

class MobileMessagerBase : public Messager{
public:
    virtual void PlaySound(){
        //==========
    }
    virtual void DrawShape(){
        //==========
    }
    virtual void WriteText(){
        //==========
    }
    virtual void Connect(){
        //==========
    }
};
//业务抽象
class PCMessagerLite : public PCMessagerBase {
public:
    virtual void Login(string username, string password){
        PCMessagerBase::Connect();
        //........
    }
    virtual void SendMessage(string message){
        PCMessagerBase::WriteText();
        //........
    }
    virtual void SendPicture(Image image){
        PCMessagerBase::DrawShape();
        //........
    }
};
class PCMessagerPerfect : public PCMessagerBase {
public:
    virtual void Login(string username, string password){
        PCMessagerBase::PlaySound();
        //********
        PCMessagerBase::Connect();
        //........
    }
    virtual void SendMessage(string message){
        PCMessagerBase::PlaySound();
        //********
        PCMessagerBase::WriteText();
        //........
    }
    virtual void SendPicture(Image image){
        PCMessagerBase::PlaySound();
        //********
        PCMessagerBase::DrawShape();
        //........
    }
};
class MobileMessagerLite : public MobileMessagerBase {
public:
    
    virtual void Login(string username, string password){
        MobileMessagerBase::Connect();
        //........
    }
    virtual void SendMessage(string message){
        MobileMessagerBase::WriteText();
        //........
    }
    virtual void SendPicture(Image image){
        MobileMessagerBase::DrawShape();
        //........
    }
};
class MobileMessagerPerfect : public MobileMessagerBase {
public:
    virtual void Login(string username, string password){
        MobileMessagerBase::PlaySound();
        //********
        MobileMessagerBase::Connect();
        //........
    }
    virtual void SendMessage(string message){
        MobileMessagerBase::PlaySound();
        //********
        MobileMessagerBase::WriteText();
        //........
    }
    virtual void SendPicture(Image image){
        MobileMessagerBase::PlaySound();
        //********
        MobileMessagerBase::DrawShape();
        //........
    }
};
void Process(){
        //编译时装配
        Messager *m = new MobileMessagerPerfect();
}

bridge2.cpp

class Messager{
protected:
     MessagerImp* messagerImp;//...
public:
    virtual void Login(string username, string password)=0;
    virtual void SendMessage(string message)=0;
    virtual void SendPicture(Image image)=0;
    
    virtual ~Messager(){}
};
class MessagerImp{
public:
    virtual void PlaySound()=0;
    virtual void DrawShape()=0;
    virtual void WriteText()=0;
    virtual void Connect()=0;
    
    virtual ~MessagerImp(){}
};
//平台实现 n
class PCMessagerImp : public MessagerImp{
public:
    virtual void PlaySound(){
        //**********
    }
    virtual void DrawShape(){
        //**********
    }
    virtual void WriteText(){
        //**********
    }
    virtual void Connect(){
        //**********
    }
};
class MobileMessagerImp : public MessagerImp{
public:
    
    virtual void PlaySound(){
        //==========
    }
    virtual void DrawShape(){
        //==========
    }
    virtual void WriteText(){
        //==========
    }
    virtual void Connect(){
        //==========
    }
};
//业务抽象 m
//类的数目：1+n+m

class MessagerLite :public Messager {
public:
    virtual void Login(string username, string password){
        messagerImp->Connect();
        //........
    }
    virtual void SendMessage(string message){
        messagerImp->WriteText();
        //........
    }
    virtual void SendPicture(Image image){
        messagerImp->DrawShape();
        //........
    }
};
class MessagerPerfect  :public Messager {
public:
    
    virtual void Login(string username, string password){
        messagerImp->PlaySound();
        //********
        messagerImp->Connect();
        //........
    }
    virtual void SendMessage(string message){
        messagerImp->PlaySound();
        //********
        messagerImp->WriteText();
        //........
    }
    virtual void SendPicture(Image image){
        messagerImp->PlaySound();
        //********
        messagerImp->DrawShape();
        //........
    }
};
void Process(){
    //运行时装配
    MessagerImp* mImp=new PCMessagerImp();
    Messager *m =new Messager(mImp);
}
模式定义

将抽象部分（业务功能）与实现部分（平台实现）分离，使它们都可以独立地变化。 -----《设计模式》GoF

结构（Structure)

在这里插入图片描述

要点总结
  • Bridge模式使用“对象间的组合关系”解耦了抽象和实现之间固有的绑定关系，使得抽象和实现可以沿着各自的维度来变化。所谓抽象和实现沿着各自维度的变化，即“子类化”它们。
  • Bridge模式有时候类似于多继承方案，但是多继承方案往往违背单一职责原则（即一个类只有一个变化的原因），复用性比较差。Bridge模式是比多继承方案更好的解决方法。
  • Bridge模式的应用一般在“两个非常强的变化维度”，有时一个 类也有多于两个的变化维度，这时可以使用Bridge的扩展模式。
yangyang_z
关注
专栏目录
面向对象设计与分析40讲（2）设计原则之单一职责
二进制君
04-17 1309
概念 单一职责原则(Single Responsibility Principle, SRP)：一个类只负责一个功能领域中的相应职责，或者可以定义为：就一个类而言，应该只有一个引起它变化的原因。 简述：单一职责原则可以看作是低耦合、高内聚在面向对象原则上的引申与扩展，将职责定义为引起变化的原因，以提高内聚性来减少引起变化的原因。职责过多，可能引起它变化的原因就越多，这将导致职责依赖，相互之间就产生影响，从而极大的损伤其内聚性和耦合度。单一职责，通常意味着单一的功能，因此不要为类实现过多的功能点，以保证实体
c++设计模式
农家小院
10-28 1233
设计模式之c++
6.装饰模式（Decorator）
qq_35484146的博客
01-23 197
本文讲述了单一职责模式中的装饰模式，介绍了装饰模式的动机、定义、结构、代码实例，最后进行了总结。 再次感谢GeekBand的李建忠老师、GOF等前辈 1. “单一职责”模式: 在软件组件的设计中，如果责任划分的不清晰，使用继承得到的结果往往是随着需求的变化，子类急剧膨胀，同时充斥着重复代码，这时候的关键是划清责任。 典型模式 Decorator 装饰模式 Bridge 2. 动机（Motivation） 在某些情况下我们可能会“过度地使用继承来扩展对象的功能”，由于继承为类型引入了静态特质[.
【学习笔记】C++下的单一职责原则（程杰-大话设计模式）
野生C++程序员
06-13 295
《大话设计模式》单一职责原则学习笔记
C++设计模式单一职责模式（四）
一个不甘于此的弱鸡
09-13 150
单一职责模式： 在软件组件的设计中，如果责任划分不清晰，使用继承得到的结果往往是随着需求的变化，子类急剧膨胀，同时充斥着重复代码，这时候的关键是划清责任。 典型模式 Decorator Bridge ...
入门设计原则C++实现一：单一职责原则
鲁点点的博客
08-03 450
上面代码Animal类中的behavior方法做了所有操作，不管传入的参数是何值，执行的操作是固定的。但实际并不是我们想要的，比如当传入是燕子/鱼的时候，就会出现违背常理结果。究其原因就是animal类扮演的角色过多，处理出现异常了，这种就是违背的单一职责原则较为典型的例子。此时需要考虑将类拆分类1，类2， 类1负责功能A，类2负责功能B。变更引起的风险降低，变更是必不可少的，如果接口的单一职责做得好，一个接口修改只对相应的实现类有影响，对其他的接口无影响，这对系统的扩展性、维护性都有非常大的帮助。...
C++ 23种设计模式.zip
07-29
同时，了解并掌握这些设计模式也有助于开发者更好地理解和应用面向对象设计原则，如单一职责原则、开闭原则、里氏替换原则、依赖倒置原则以及接口隔离原则。在实际工作中，灵活运用设计模式能够显著提高软件质量和...
C++设计模式课件
08-24
C++设计模式是一种在软件开发中，为了应对特定问题或挑战而提炼出的重用性解决方案，它们体现了面向对象设计的精髓。本课件聚焦于23种最常见且广泛应用于C++编程的设计模式，旨在帮助读者深入理解并熟练运用这些模式...
C++设计模式之装饰模式(Decorator)
08-27
在C++中，装饰模式能够帮助我们保持类的封装性和单一职责原则，同时允许在运行时动态地添加或移除对象的行为。 首先，装饰模式包含以下几个关键角色： 1. **组件接口（Component）**：定义了被装饰对象的公共接口...
C++设计模式之简单工厂模式实例
09-04
简单工厂模式是一种设计模式，它将对象的创建过程封装在一个单独的工厂类中，使得客户端无需知道具体的对象创建逻辑，只需通过工厂类提供的接口来获取所需对象。这种模式有助于降低系统的耦合度，提高可扩展性和可...
单一职责原则（C++)
先锋小牛
08-31 1350
概念     就一个类而言，应该仅有一个引起它变化的原因。每个类实现一个功能。 简述     单一职责原则可以看作是低耦合、高内聚在面向对象原则上的引申，将职责定义为引起变化的原因，以提高内聚性来减少引起变化的原因。职责过多，可能引起它变化的原因就越多，这将导致职责依赖，相互之间就产生影响，从而极大的损伤其内聚性和耦合度。单一职责，通常意味着单一的功能，因此不要为类实现过多的功能点，以保证实
【C++】单一职责模式
最新发布
AAADiao的博客
12-14 552
在面向对象设计中，单一职责原则（Single Responsibility Principle，简称 SRP）是 SOLID 原则之一，提出了一个类应该只有一个修改的理念。具体来说，一个类应该只有一个引起它变化的原因，即一个类应该只有一个责任。如果一个类承担的责任过多，那么对这个类的修改就会影响到所有依赖它的地方。
以C/C++语法浅谈六大设计原则（三）——单一职责原则（Single Responsibility Principle）
尘海折柳的博客
01-15 1197
单一职责原则(Single Responsibility Principle, SRP)：一个类只负责一个功能领域中的相应职责，或者可以定义为：就一个类而言，应该只有一个引起它变化的原因。 简述：单一职责原则(Single Responsibility Principle, SRP)可以看作是低耦合、高内聚在面向对象原则上的引申与扩展，将职责定义为引起变化的原因，以提高内聚性来减少引起变化的原因...
《大话设计模式》读书笔记之C++实现--chapter3单一职责原则
WingC的博客
03-30 512
单一职责的原则准确解释为：“就一个类来说，应该仅有一个引起它变化的原因”。如果一个类承担的职责过多，就相当于把这些职责耦合在一起，一个职责的变化可能会抑制或削弱这个类完成其他职责的能力。当变化发生时，设计会受到意想不到的破坏。 举一个例子来说，俄罗斯方块的游戏逻辑和界面应该分开，当移植到不同平台上时，游戏逻辑代码本身不会发生改动，仅需要对界面部分作出修改。如果你能想到多余一个的动机去改变类，那么
单一职责原则
rover
05-14 189
动机：阅读《敏捷软件开发–原则、模式与实践》很长时间，收益非浅。不过书中的示例都是c++或者java的，想把他们改写成as的模式，同时增加一些自己的感想。 这条原则曾经被称之为内聚性(cohesion)。他们把内聚性定义为：一个模块的组合元素之间的功能相关性。在本章中，我们稍微改变一下它的含义,把内聚性和引起一个模块或者类改变的作用力联系起来。 1.单一职责原则（SRP） 就一个类而言，应该...
C++ 设计模式 - 6大设计原则之单一职责原则
NewBorad的专栏
05-20 2561
《设计模式之禅》的读后感
设计模式（一）单一职责原则
张付兵的专栏
03-09 565
我们在做面向对象设计和开发（OOD和OOP）的时候，最底层的基石是6大设计原则。GoF的23种设计模式以及新生代设计模式的扩展（如：MVC和AOP），其本职都是至此延伸。这6大设计原则，最终目的是开闭原则，方便进行扩展和维护。在面向对象语言中，使用其特性（封装、继承、多态）进行表现，也加入聚合和组合。 6大设计原则罗列如下： 1、单一职责原则； 2、里氏替换原则； 3、依赖倒置原则； 4
c++ 设计原则 - 单一职责原则
weixin_45053845的博客
11-12 308
然后，在需要的地方调用 FileCompressor 的方法进行压缩和解压操作，这样就实现了功能的扩展，并且不会影响到原有的文件读取和写入类。通过以上的两个场景，我们可以看到，根据单一职责原则的设计，当需求发生变化时，我们可以独立地扩展或修改相应的类，而不会对其他部分的代码造成影响。设计遵循单一职责原则：每个类只负责一项工作，当需求发生变化时，只需要修改对应的类，而无需影响其他类。当需求发生变化时，根据单一职责原则的设计，我们可以针对不同的需求独立地扩展或修改相应的类，而不会影响其他部分的代码。
C++ 设计模式----“单一职责“模式
呵呵哒!的博客
06-15 907
C++ 设计模式----“单一职责”模式“
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值