C++ 设计模式----“单一职责“模式

news2024/11/26 9:36:17

二、“单一职责”模式

在软件组件的设计中，如果责任划分的不清晰，使用继承得到的结果往往是随着需求的变化，子类急剧膨胀，同时充斥着重复代码，这时候的关键是划清责任。

 典型模式

• Decorator

• Bridge

【1】Decorator 装饰模式

**动机（Motivation）**💡：

 在某些情况下我们可能会“过度地使用继承来扩展对象的功能” ，由于继承为类型引入的静态特质，使得这种扩展方式缺乏灵活性；并且随着子类的增多（扩展功能的增多），各种子类的组合（扩展功能的组合）会导致更多子类的膨胀。

**问题思考（Consider）**🤔：

 如何使**“对象功能的扩展”能够根据需要来动态地实现？同时避免“扩展功能的增多”带来的子类膨胀问题**？从而使得任何“功能

扩展变化”所导致的影响将为最低？

业务需求：加密的操作是一样的，只是流的读取操作是不一样的。

C++执行代码：

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();

}

在这里插入图片描述

类的总数：1+n+n*m!/2

【改进decorator1.cpp】用组合代替继承
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

【改进decorator1.cpp】三个子类变为一个子类（CryptoFileStream、CryptoNetworkStream、CryptoMemoryStream）->（CryptoStream）

在这里插入图片描述

【改进decorator1.cpp】缓冲流也是一样的改造（BufferedFileStream、BufferedNetworkStream、BufferedMemoryStream）->（BufferedStream）

在这里插入图片描述

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(char data){
        //额外的加密操作...
        Stream::Write(data);//写文件流
        //额外的加密操作...
    }
};


// 三个子类变为一个子类，用组合代替继承
class BufferedStream : public Stream{
    
    Stream* stream;//...
    
public:
    BufferedStream(Stream* stm):stream(stm){
        
    }
    virtual char Read(int number){
        // ...
    }
    virtual void Seek(int position){
        // ...
    }
    virtual void Write(char data){
        // ...
    }
};


void Process(){
    //运行时装配
    FileStream* s1=new FileStream();
    CryptoStream* s2=new CryptoStream(s1);
    
    BufferedStream* s3=new BufferedStream(s1);
    
    BufferedStream* s4=new BufferedStream(s2);
    
}

改造decorator2.cpp（由于两个子类有相同的成员Stream*，所以这个成员要往上提）

在这里插入图片描述

在这里插入图片描述

1、编写DecoratorStream中间类继承Stream（装饰类）

在这里插入图片描述

2、

在这里插入图片描述

3、

在这里插入图片描述

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){
        //写内存流
    }
    
};

//扩展操作
// 由于两个子类有相同的成员Stream*，所以这个成员要往上提
class 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(char data){
        //额外的加密操作...
        Stream::Write(data);//写文件流
        //额外的加密操作...
    }
};

class BufferedStream : public DecoratorStream{
    Stream* stream;//...
public:
    BufferedStream(Stream* stm):DecoratorStream(stm){
        
    }

    virtual char Read(int number){
        // ...
    }
    virtual void Seek(int position){
        // ...
    }
    virtual void Write(char data){
        // ...
    }
};

void Process(){
    //运行时装配
    FileStream* s1=new FileStream();
    
    CryptoStream* s2=new CryptoStream(s1);
    
    BufferedStream* s3=new BufferedStream(s1);
    
    BufferedStream* s4=new BufferedStream(s2);
}

在这里插入图片描述

类的总数：1+n+1+m

使**“对象功能的扩展”能够根据需要来动态**地实现：

在这里插入图片描述

网上代码(来自这个博主):https://github.com/chouxianyu/design-patterns-cpp

Decorator.cpp

#include <iostream>
class Component
{
public:
  virtual ~Component() {}
  
  virtual void operation() = 0;
  // ...
};

class ConcreteComponent : public Component
{
public:
  ~ConcreteComponent() {}
  
  void operation()
  {
    std::cout << "Concrete Component operation" << std::endl;
  }
  // ...
};

class Decorator : public Component
{
public:
  ~Decorator() {}
  
  Decorator( Component *c ) : component( c ) {}
  
  virtual void operation()
  {
    component->operation();
  }
  // ...

private:
  Component *component;
};

class ConcreteDecoratorA : public Decorator
{
public:
  ConcreteDecoratorA( Component *c ) : Decorator( c ) {}
  
  void operation()
  {
    Decorator::operation();
    std::cout << "Decorator A" << std::endl;
  }
  // ...
};

class ConcreteDecoratorB : public Decorator
{
public:
  ConcreteDecoratorB( Component *c ) : Decorator( c ) {}
  
  void operation()
  {
    Decorator::operation();
    std::cout << "Decorator B" << std::endl;
  }
  // ...
};


int main()
{
  //运行时装配
  ConcreteComponent  *cc = new ConcreteComponent();
  ConcreteDecoratorB *db = new ConcreteDecoratorB( cc );
  ConcreteDecoratorA *da = new ConcreteDecoratorA( db );
  
  Component *component = da;
  component->operation();
  
  delete da;
  delete db;
  delete cc;
  
  return 0;
}

模式定义

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

——《设计模式》GoF

结构（Structure）

在这里插入图片描述

要点总结

 通过采用组合而非继承的手法， Decorator模式实现了在运行时 动态扩展对象功能的能力，而且可以根据需要扩展多个功能。避免 了使用继承带来的“灵活性差”和“多子类衍生问题” 。

 Decorator类在接口上表现为is-a Component的继承关系，即 Decorator类继承了Component类所具有的接口。但在实现上又 表现为has-a Component的组合关系，即Decorator类又使用了 另外一个Component类。

 Decorator模式的目的并非解决“多子类衍生的多继承”问题， Decorator模式应用的要点在于解决“主体类在多个方向上的扩展 功能”——是为“装饰”的含义。

【2】Bridge 桥模式

**动机（Motivation）**💡：

 由于某些类型的固有的实现逻辑，使得它们具有两个变化的维度，乃至多个维度的变化。

**问题思考（Consider）**🤔：

 如何**应对这种“多维度的变化”？**如何利用面向对象技术来使得类型可以轻松地沿着两个乃至多个方向变化，而不引入额外的复杂度？

业务需求：

①登录（Login），发送消息（SendMessage），发送图片（SendPicture），

②播放声音（PlaySound），画图（DrawShape），写文字（WriteText），连接（Connect）

等需求。假设我们要支持PC的平台设计,也要支持mobile的平台设计，需要在不同的平台上推荐出不同的功能。比如说我们要推出精简版（Lite），还有一个完美版（Perfect）。

bridge1.cpp

#include<string>
using std::string;
class Image{

};

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(){}
};


//平台实现 n
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(){
        //==========
    }
};



//业务抽象 m
//类的数目：1+n+m*n
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();
}
  • 平台实现 n
  • 业务抽象 m
  • 类的数目：1+n+m*n

bridge2.cpp

第一步：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
第二步：

我们发现PCMessagerLite和MobileMessagerLite的业务一样，可以整合成MessagerLite；

PCMessagerPerfect和MobileMessagerPerfect的业务一样，可以整合成MessagerPerfect

在这里插入图片描述
在这里插入图片描述

第三步：

存在只override一些虚函数，有一些没有override.如果直接让PCMessagerBase和MobileMessagerBase去继承Messager是不合适的。所以我们需要把Messager做一个拆分。

在这里插入图片描述

修改平台实现：

在这里插入图片描述

修改Lite版本和Perfect版本：

在这里插入图片描述

发现Messager的子类MessagerLite和MessagerPerfect都有MessagerImp* messagerImp;字段，可以把它往上提。

在这里插入图片描述
在这里插入图片描述

#include<string>
using std::string;
class Image{

};

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;
    
    Messager(MessagerImp* p=nullptr){
        messagerImp=p;
    }
    virtual ~Messager(){}
};

// 不同的变化方向(业务和平台)，所以分为两个类
class MessagerImp{
public:
    virtual void PlaySound()=0;
    virtual void DrawShape()=0;
    virtual void WriteText()=0;
    virtual void Connect()=0;
    
    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();
        //........
    }

    MessagerLite(MessagerImp* p=nullptr){
        messagerImp=p;
    }
};

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();
        //........
    }
    
    MessagerPerfect(MessagerImp* p = nullptr) {
        messagerImp = p;
    }
};

void Process(){
    //运行时装配
    MessagerImp* mImp=new PCMessagerImp();
    Messager *m = new MessagerLite(mImp);
}

网上代码(来子这个博主):https://github.com/chouxianyu/design-patterns-cpp

Bridge.cpp

#include <iostream>
class Implementor
{
public:
  virtual ~Implementor() {}
  
  virtual void action() = 0;
  // ...
};

class ConcreteImplementorA : public Implementor
{
public:
  ~ConcreteImplementorA() {}
  
  void action()
  {
    std::cout << "Concrete Implementor A" << std::endl;
  }
  // ...
};

class ConcreteImplementorB : public Implementor
{
public:
  ~ConcreteImplementorB() {}
  
  void action()
  {
    std::cout << "Concrete Implementor B" << std::endl;
  }
  // ...
};

class Abstraction
{
public:
  virtual ~Abstraction() {}
  
  virtual void operation() = 0;
  // ...
};

class RefinedAbstraction : public Abstraction
{
public:
  ~RefinedAbstraction() {}
  
  RefinedAbstraction(Implementor *impl) : implementor(impl) {}
  
  void operation()
  {
    implementor->action();
  }
  // ...

private:
  Implementor *implementor;
};


int main()
{
  Implementor *ia = new ConcreteImplementorA;
  Implementor *ib = new ConcreteImplementorB;
  
  Abstraction *abstract1 = new RefinedAbstraction(ia);
  abstract1->operation();
  
  Abstraction *abstract2 = new RefinedAbstraction(ib);
  abstract2->operation();
  
  delete abstract1;
  delete abstract2;
  
  delete ia;
  delete ib;
  
  return 0;
}

在这里插入图片描述

模式定义

将抽象部分(业务功能)与实现部分(平台实现)分离，使它们都可以独立地变化。

——《设计模式》GoF

结构（Structure）

在这里插入图片描述

要点总结

 Bridge模式使用“对象间的组合关系”解耦了抽象和实现之间固 有的绑定关系，使得抽象和实现可以沿着各自的维度来变化。所谓抽象和实现沿着各自纬度的变化，即“子类化”它们。

 Bridge模式有时候类似于多继承方案，但是多继承方案往往违背单一职责原则（即一个类只有一个变化的原因），复用性比较差。Bridge模式是比多继承方案更好的解决方法。

 Bridge模式的应用一般在“两个非常强的变化维度”，有时一个类也有多于两个的变化维度，这时可以使用Bridge的扩展模式。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/651474.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

RabbitMQ高阶使用延时任务

RabbitMQ高阶使用延时任务

目录 1 从打车开始说起1.1 需要解决的问题1.1.1 打车超时 2 延时任务2.1 什么是延时任务2.1.1 和定时任务区别 2.2 延时队列使用场景2.3 常见方案2.3.1 数据库轮询2.3.1 JDK的延迟队列2.3.3 netty时间轮算法2.3.4 使用消息队列 2.4 延时队列2.4.1 TTL(消息过期时间) 2.4.1.1 配…
阅读更多...
第七十五天学习记录：高等数学：定积分（宋浩板书）

第七十五天学习记录：高等数学：定积分（宋浩板书）

定积分是微积分中的一个重要概念&#xff0c;表示在给定区间上函数曲线下的面积或有向曲线与坐标轴围成的面积。定积分通常用符号 ∫ 来表示&#xff0c;具体形式为 ∫f(x) dx。 对于给定的函数 f(x) 和区间 [a, b]&#xff0c;定积分的计算可以通过求函数 f(x) 在该区间上的原…
阅读更多...
【C++】STL的vector容器

【C++】STL的vector容器

目录 2、vector容器 1.1模板实例化 1.2定义与初始化vector对象 2.1vector构造函数 2.2vector赋值操作 2.2vector的容量和大小 2.4vector的插入 2.5vector的删除 2.6vector数据存取 2.7vector互换容器 2.8vector预留空间 2、vector容器 vector是C最常用的容器之一&a…
阅读更多...
深度学习(神经网络)

深度学习(神经网络)

文章目录 神经网络历史形式神经元模型&#xff08;M-P模型&#xff09;感知器多层感知器 误差反向传播算法误差函数和激活函数误差函数二次代价函数交叉熵代价函数 激活函数sigmoid函数RELU函数 似然函数softmax函数 随机梯度下降法批量学习方法在线学习小批量梯度下降法 学习率…
阅读更多...
＜Linux开发＞驱动开发 -之-阻塞、非阻塞IO和异步通知

＜Linux开发＞驱动开发 -之-阻塞、非阻塞IO和异步通知

&#xff1c;Linux开发&#xff1e;驱动开发 -之-阻塞、非阻塞IO和异步通知 交叉编译环境搭建&#xff1a; &#xff1c;Linux开发&#xff1e; linux开发工具-之-交叉编译环境搭建 uboot移植可参考以下&#xff1a; &#xff1c;Linux开发&#xff1e; -之-系统移植 uboot移…
阅读更多...
easyui01(基本布局)

easyui01(基本布局)

一.概述 1.What&#xff1f; jQuery EasyUI是一组基于jQuery的UI插件集合体&#xff0c;能帮助web开发者更轻松的打造出功能丰富并且美观的UI界面 2.Why&#xff1f; ①.使用easyui 不需要写很多代码&#xff0c;只需要编写一些简单 HTML 标记&#xff0c;就可以定义用户界…
阅读更多...
Java优先级队列源码分析

Java优先级队列源码分析

先导课程&#xff1a;二叉堆学习 优先级队列 1. Priority Queue 优先级队列&#xff08;Priority Queue&#xff09;也是队列 普通队列按照FIFO原则&#xff0c;也就是先进先出优先级队列按照优先级高低进行出队&#xff0c;比如将优先级最高的元素作为队头优先出队 基本接口和…
阅读更多...
Vue3中Composition 其他一些API

Vue3中Composition 其他一些API

一、 Reactive判断的API 1. isProxy 检查对象是否由reactive或者readonly创建的proxy &#xff0c;返回一个布尔值 <script setup> import { reactive, readonly, isProxy } from vuelet foo readonly({ name: WFT1 }) // 其中的属性不可修改let bar reactive({ n…
阅读更多...
DeepSpeed结合Megatron-LM训练GPT2模型笔记（上）

DeepSpeed结合Megatron-LM训练GPT2模型笔记（上）

文章目录 0x0. 前言0x1. Megatron使用单卡训练GPT2依赖安装准备训练数据训练详细流程和踩坑 0x2. Megatron使用单卡预测训练好的GPT2模型0x3. 参数量和显存估计参数量估计训练显存占用估计 0x4. Megatron使用多卡训练GPT2模型2卡数据并行2卡模型并行 0x5. 总结 0x0. 前言 本文…
阅读更多...
【V4L2】 v4l2框架分析之v4l2_subdev

【V4L2】 v4l2框架分析之v4l2_subdev

文章目录 一、v4l2_subdev简介二、初始化v4l2_subdev三、注册/注销subdev四、异步注册子设备 一、v4l2_subdev简介 相关源码文件&#xff1a; /include/media/v4l2-subdev.h/drivers/media/v4l2-core/v4l2-subdev.c 在linux内核中&#xff0c;许多驱动程序需要与子设备通信&…
阅读更多...
【嵌入式linux】spi驱动加载后probe函数未执行的问题

【嵌入式linux】spi驱动加载后probe函数未执行的问题

【嵌入式linux】spi驱动加载后probe函数未执行的问题 问题描述解决办法 问题描述 嵌入式linux平台下的spi分为设备、总线和驱动&#xff0c;一般半导体原厂已经实现好了spi设备和总线的相关代码&#xff0c;开发者只需根据实际使用情况修改设备树以及编写驱动部分的代码即可。…
阅读更多...
Android进阶 四大组件的工作过程（四）：ContentProvider的工作过程

Android进阶 四大组件的工作过程（四）：ContentProvider的工作过程

Android进阶 四大组件的工作工程&#xff08;四&#xff09;&#xff1a;ContentProvider的工作过程 导语 本篇是介绍四大组件的最后一篇文章&#xff0c;前三篇文章里我们已经介绍了Activity&#xff0c;Service以及Broadcast的工作流程&#xff0c;那么这篇文章我们就来介绍…
阅读更多...
【数据结构与算法分析】一文搞定插入排序、交换排序、简单选择排序、合并排序的代码实现并给出详细讲解

【数据结构与算法分析】一文搞定插入排序、交换排序、简单选择排序、合并排序的代码实现并给出详细讲解

文章目录 排序相关的基本概念排序算法及其实现插入排序直接插入排序折半插入排序希尔排序 交换排序冒泡排序快速排序 合并排序归并排序简单选择排序 算法比较 排序相关的基本概念 排序&#xff1a;将数组中所有元素按照某一顺序(从小到大或从大到小)重新排列的过程。排序算法的…
阅读更多...
DJ2-5 内容分发网络 CDN

DJ2-5 内容分发网络 CDN

目录 单一的大规模数据中心 内容分发网络 CDN 单一的大规模数据中心 存在三个问题&#xff1a; ① 如果客户远离数据中心&#xff0c;服务器到客户的分组将跨越许多通信链路并很可能通过许多 ISP&#xff0c;给用户带来恼人的时延。 ② 流行的视频很可能经过相同的通信链路…
阅读更多...
[C++11] 智能指针

[C++11] 智能指针

长路漫漫&#xff0c;唯剑作伴。 目录 长路漫漫&#xff0c;唯剑作伴。 为什么需要智能指针 RAII 使用RAII思想管理内存 重载 * 和-> 总结一下智能指针的原理&#xff1a; C的智能指针和拷贝问题 auto_ptr (C98) ​编辑 auto_ptr的实现原理…
阅读更多...
EmGUCV中类函数 FastFeatureDetector使用详解

EmGUCV中类函数 FastFeatureDetector使用详解

FastFeatureDetector Class 释义&#xff1a;FAST&#xff08;加速检测特&#xff09;关键点检测器&#xff0c;源自 E. Rosten ("Machine learning for high-speed corner detection, 2006). 继承关系&#xff1a;Emgu.CV.Features2D.FastFeatureDetector 派生&#xff…
阅读更多...
记录好项目D5

记录好项目D5

记录好项目 你好呀&#xff0c;这里是我专门记录一下从某些地方收集起来的项目&#xff0c;对项目修改&#xff0c;进行添砖加瓦&#xff0c;变成自己的闪亮项目。修修补补也可以成为毕设哦 本次的项目是 商品信息管理系统 技术栈&#xff1a;SpringBoot Mybatis Thymelea…
阅读更多...
MATLAB|主动噪声和振动控制算法——对较大的次级路径变化具有鲁棒性

MATLAB|主动噪声和振动控制算法——对较大的次级路径变化具有鲁棒性

\ &#x1f4a5;&#x1f4a5;&#x1f49e;&#x1f49e;欢迎来到本博客❤️❤️&#x1f4a5;&#x1f4a5; &#x1f3c6;博主优势&#xff1a;&#x1f31e;&#x1f31e;&#x1f31e;博客内容尽量做到思维缜密&#xff0c;逻辑清晰&#xff0c;为了方便读者。 ⛳️座右铭…
阅读更多...
细谈容器化技术实现原理--以Docker为例

细谈容器化技术实现原理--以Docker为例

目录 一、Docker解决了什么 二、容器的发展过程 三、容器基础 3.1. 容器实现的原理&#xff1a; ⚠️原理详解&#xff1a; 3.1.1. Namespace 3.1.2. Cgroups 3.1.3. chroot 四、Volume 4.1. Docker是如何做到把一个宿主机上的目录或者文件&#xff0c;挂载到容器里面…
阅读更多...
4. 数组更新检测

4. 数组更新检测

4.1 v-for更新监测 当v-for遍历的目标结构改变, Vue触发v-for的更新 情况1: 数组翻转 情况2: 数组截取 情况3: 更新值 口诀: 数组变更方法, 就会导致v-for更新, 页面更新 数组非变更方法, 返回新数组, 就不会导致v-for更新, 可采用覆盖数组或this.$set() 这些方法会触发数组改…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023