C++设计模式笔记

设计模式

如何解决复杂性?

分解

核心思想:分而治之,将大问题分解为多个小问题,将复杂问题分解为多个简单的问题。

抽象

核心思想:从高层次角度讲,人们处理复杂性有一个通用的技术,及抽象。由于不能掌握全部的复杂对象,选择护士他的非本质细节,而去处理泛化和理想化的对象模型。

总结来说就是,复用最好的代码就是复用性高。

面向对象设计原则

对象的概念

  • 从语言实现层面来看,对象封装了代码和数据。
  • 从规格层面讲,对象是一系列可被使用的公共接口。
  • 从概念层面讲,对象时某种拥有责任的抽象。

设计原则

依赖倒置原则(DIP):

  • 高层模块(稳定)不应该依赖于低层模块(变化)二者都应该依赖于抽象(稳定)。
  • 抽象(稳定)不应该依赖于实现细节(变化),实现细节应该依赖于抽象(稳定)。

开放封闭原则(OCP):

  • 对扩展开放,对更改封闭。
  • 类模块应该是可扩展的,但是不可修改。

单一职责原则(SRP):

  • 一个类应该仅有一个引起它变化的原则。
  • 变化的方向隐含着类的责任。

Liskov替换原则(LSP):

  • 子类必须能够替换他们的基类。
  • 继承表达类型抽象

接口隔离原则(ISP):

  • 不应该强迫客户程序依赖他们不用的方法。
  • 接口应该小而完备。

优先使用对象组合,而不是类继承

  • 类继承通常为“白箱复用”,对象组合通常为“黑箱复用”。
  • 继承在某种程度上破坏了封装性,子类父类耦合度很高。
  • 而对象组合则只要求被组合的对象具有良好定义的接口,耦合度低。

封装变化点

  • 使用封装来创建对象之间的分界层,让设计者可以在分界层的一侧进行修改,而不会对另一侧产生不良影响,从而实现层次间的松耦合。

针对接口与编码,而不是针对实现编程产业强盛的标志

  • 不将变量类型声明为某个特定的具体类,而是声明为某个接口
  • 客户程序无需获知对象的具优类型,只需要知道对象所具有的接口。
  • 减少系统中各部分的依赖关系从而实现“高内聚、松耦合’的类型设计方案。

GOF-23模式分类

目的来看:

  • 创建型模式:将对象的部分创建工作延迟到子类或者其他对象,从而应对需求变化为对象创建时具体类型实现引来的冲击。
  • 结构型模式:通过类继承或者对象组合获得更灵活的结构,从而应对需求变化为对象的结构带来的冲击。
  • 行为型模式:通过类继承或者对象组合来划分类与对象间的职责,从而应对需求变化为多个交互的对象带来的冲击。

范围来看:

  • 类模式处理类与子类的静态关系。
  • 对象模式处理对象间的动态关系。

C++设计模式

工厂模式

工厂模式:主要是封装了对象的创建。

简单工厂(Simple Factory)

优点:

  1. 把对象的创建封装在一个接口函数里面,通过传入不同的标识,返回创建的对象。
  2. 使用者不需要自己负责new对象,不用了解对象创建的详细过程。

缺点:

  1. 提供创建对象实例的接口函数不闭合,不能对修改关闭。

工厂方法(Factory Method)

优点:

  1. 使用Factory基类,提供一个纯虚函数(创建产品),定义派生类(具体产品的工厂)负责创建对应的产品,可以做到不同的产品在不同的工厂进行创建。能对现有工厂以及产品的修改关闭

缺点:

  1. 忽略了产品之间的关联关系,属于一个产品簇的不应该放到不同的工厂里面去创建。不符合产品对象创建逻辑;
  2. 工厂类太多,难以维护。

抽象工厂(Abstact Factory)

优点:

  1. 把现有关联关系、属于同一个产品簇的所有产品创建的接口函数放在一个抽象工厂里面,派生类(具体产品的工厂)应该负责创建该产品簇里面的所有产品。

这里使用了一个汽车生产的工厂示例,列举了简单工厂和工厂方法,并使用智能指针进行对象空间优化回收。

简单工厂和工厂方法

#include <iostream>
#include <string>
#include<memory>

using namespace std;

class Car
{
public:
    Car(string name):_name(name){}
    virtual void show() = 0; //定义纯虚函数,子类必须实现

protected:
    string _name;

private:
};
class BMW:public Car
{
public:
    // 使用Car(name)类似于_name(name),还是用了Car的_name,
    // 子类继承父类的构造函数可以参考 https://blog.csdn.net/aquapisces/article/details/104371658
    BMW(string name) : Car(name){};
    void show()
    {
        cout << "获取了一辆宝马汽车" << _name << endl;
    } 
protected : 
private:
};
class Audi : public Car
{
public:
    // 使用Car(name)类似于_name(name),还是用了Car的_name,
    // 子类继承父类的构造函数可以参考 https://blog.csdn.net/aquapisces/article/details/104371658
    Audi(string name) : Car(name){};
    void show()
    {
        cout << "获取了一辆奥迪汽车" << _name << endl;
    }

protected:
private:
};

// ------------------------------------------------------------------------------------------
/*
简单工厂存在以下问题:开闭原则,新增一个汽车则需要修改很多代码;BMW类和Audi类都在一个工厂里面生产
*/
enum CarType
{
    bmw,audi
};
class SimpleFactory
{
public:
    Car* createCar(CarType ct)
    {
        switch (ct)
        {
        case bmw:
            return new BMW("X1");
        case audi:
            return new Audi("A6");
        default:
            cout << "传入工厂的参数不正确:" << ct << endl;
            break;
        }
        return nullptr;
    }
};
// ------------------------------------------------------------------------------------------
/*
工厂方法
*/
class Factory
{
public:
    virtual Car* createCar(string name) = 0;
};
class BMWFactory:public Factory
{
public:
    Car* createCar(string name)
    {
        return new BMW(name);
    }
};
class AudiFactory : public Factory
{
public:
    Car *createCar(string name)
    {
        return new Audi(name);
    }
};
// ------------------------------------------------------------------------------------------

int main()
{
    // unique_ptr无法进行普通拷贝构造和赋值unique_ptr<Car> p1=new BMW("X1");是错误的
    // 最原始的对象产生
    unique_ptr<Car> p1(new BMW("X1"));
    unique_ptr<Car> p2(new Audi("A6"));

    // 简单工厂
    // unique_ptr<SimpleFactory> factory(new SimpleFactory());
    // unique_ptr<Car> p1(factory->createCar(bmw));
    // unique_ptr<Car> p2(factory->createCar(audi));

    // 工厂方法
    // unique_ptr<Factory> bmwFactory(new BMWFactory);
    // unique_ptr<Factory> audiFactory(new AudiFactory);
    // unique_ptr<Car> p1(bmwFactory->createCar("X6"));
    // unique_ptr<Car> p2(audiFactory->createCar("A8"));

    p1->show();
    p2->show();

    return 0;
}

抽象工厂方法

上一节中的工厂方法会存在一个问题,在定义了一个Factory抽象类后,每一个类将对应一个类的工厂,如BWM->BMWFactoryAudi->AudiFactory,这样会导致一个问题,在生产一类产品时,如手机充电器和充电线,那么就又需要两个工厂来实现,所以这样就会导致工厂冗余。所以,提出了抽象工厂来解决这个问题,这里以汽车的生产部件为例进行说明:

#include <iostream>
#include <string>
#include<memory>

using namespace std;

class Car
{
public:
    Car(string name):_name(name){}
    virtual void show() = 0; //定义纯虚函数,子类必须实现

protected:
    string _name;

private:
};
class BMW:public Car
{
public:
    // 使用Car(name)类似于_name(name),还是用了Car的_name,
    // 子类继承父类的构造函数可以参考 https://blog.csdn.net/aquapisces/article/details/104371658
    BMW(string name) : Car(name){};
    void show()
    {
        cout << "获取了一辆宝马汽车" << _name << endl;
    } 
protected : 
private:
};
class Audi : public Car
{
public:
    // 使用Car(name)类似于_name(name),还是用了Car的_name,
    // 子类继承父类的构造函数可以参考 https://blog.csdn.net/aquapisces/article/details/104371658
    Audi(string name) : Car(name){};
    void show()
    {
        cout << "获取了一辆奥迪汽车" << _name << endl;
    }

protected:
private:
};

class Light
{
public:
    virtual void show() = 0;
};

class BMWLight:public Light
{
public:
    void show()
    {
        cout << "BMW light!" << endl;
    }
};

class AudiLight : public Light
{
public:
    void show()
    {
        cout << "Audi light!" << endl;
    }
};
/*
抽象工厂,对一组关联关系的产品簇提供产品对象的统一创建。
有点类似于工厂方法
*/
class AbstractFactory
{
public:
    virtual Car *createCar(string name) = 0;
    virtual Light *createCarLight() = 0;
};
class BMWFactory : public AbstractFactory
{
public:
    Car *createCar(string name)
    {
        return new BMW(name);
    }
    Light *createCarLight()
    {
        return new BMWLight();
    }
};
class AudiFactory : public AbstractFactory
{
public:
    Car *createCar(string name)
    {
        return new Audi(name);
    }
    Light *createCarLight()
    {
        return new AudiLight();
    }
};

int main()
{

    // 抽象工厂方法
    unique_ptr<AbstractFactory> bmwFactory(new BMWFactory);
    unique_ptr<AbstractFactory> audiFactory(new AudiFactory);
    unique_ptr<Car> p1(bmwFactory->createCar("X6"));
    unique_ptr<Car> p2(audiFactory->createCar("A8"));
    unique_ptr<Light> l1(bmwFactory->createCarLight());
    unique_ptr<Light> l2(audiFactory->createCarLight());

    p1->show();
    p2->show();
    l1->show();
    l2->show();

    return 0;
}

代理模式

代理(proxy)模式:通过代理类,来控制实际对象的访问权限。其实也就是定义一个虚基类,子类继承虚基类实现不同级别对象的实现,可以看以下类似代码:

#include <iostream>
#include <string>
#include<memory>

using namespace std;

class VideoSite
{
public:
    virtual void freeMovie() = 0;
    virtual void vipMovie() = 0;
    virtual void ticketMovie() = 0;
};
class FixBugVideoSite:public VideoSite
{
    // 不同的用户的访问权限可能不够,所以下面三个函数有些对象不能调用
    void freeMovie()
    {
        cout << "观看免费电影" << endl;
    }
    void vipMovie()
    {
        cout << "观看vip电影" << endl;
    }
    void ticketMovie()
    {
        cout << "观看电影券电影" << endl;
    }
};

// 代理类,用于代理FixBugVideoSite
class FreeVideoSiteProxy:public VideoSite
{
public:
    FreeVideoSiteProxy()
    {
        pVideo = new FixBugVideoSite();
    }
    ~FreeVideoSiteProxy()
    {
        if(pVideo!=nullptr)
        {
            delete pVideo;
        }
        pVideo = nullptr;
    }
    void freeMovie()
    {
        pVideo->freeMovie();
    }
    void vipMovie()
    {
        cout << "您目前只是普通用户,需要升级成vip才能观看vip电影" << endl;
    }
    void ticketMovie()
    {
        cout << "您目前只是普通用户,需要购买电影券才能观看电影" << endl;
    }

private:
    VideoSite *pVideo;
};
class VipVideoSiteProxy : public VideoSite
{
public:
    VipVideoSiteProxy()
    {
        pVideo = new FixBugVideoSite();
    }
    ~VipVideoSiteProxy()
    {
        if (pVideo != nullptr)
        {
            delete pVideo;
        }
        pVideo = nullptr;
    }
    void freeMovie()
    {
        pVideo->freeMovie();
    }
    void vipMovie()
    {
        pVideo->vipMovie();
    }
    void ticketMovie()
    {
        cout << "您目前只是普通用户,需要购买电影券才能观看电影" << endl;
    }

private:
    VideoSite *pVideo;
};
int main()
{
    // unique_ptr<VideoSite> p1(new FreeVideoSiteProxy());
    unique_ptr<VideoSite> p1(new VipVideoSiteProxy());
    p1->freeMovie();
    p1->vipMovie();
    p1->ticketMovie();

    return 0;
}

观察者模式

行为型模式:主要关注的是对象之间的通信。

以观察者-监听者模式(发布-订阅模式)设计模式:主要关注的是对象的一对多的关系,也就是多个对象都依赖一个对象,当该对象的状态发生改变时,其他对象都能够结束到相应的通知。

ps:一组数据改变(数据对象)->通过这一组数据->曲线图(对象1)/柱状图(对象2)/圆饼图(对象3)。当数据对象改变时,对象1、对象2、对象3应该及时的收到相应的通知。

#include <iostream>
#include <string>
#include<list>
#include<unordered_map>

using namespace std;
/**
观察者模式/订阅模式:当一个对象发生改变时,会通知其他对象去处理对象的事件。
*/
class Observer
{
public:
    virtual void handle(int msgid) = 0;
};
class Observer1:public Observer
{
    void handle(int msgid)
    {
        switch (msgid)
        {
        case 1:
            cout << "observer1 recv 1 msg." << endl;
            break;
        case 2:
            cout << "observer1 recv 2 msg." << endl;
            break;
        default:
            cout << "observer1 recv unknow msg." << endl;
            break;
        }
    }
};
class Observer2 : public Observer
{
    void handle(int msgid)
    {
        switch (msgid)
        {
        case 3:
            cout << "observer2 recv 3 msg." << endl;
            break;
        case 2:
            cout << "observer2 recv 2 msg." << endl;
            break;
        default:
            cout << "observer2 recv unknow msg." << endl;
            break;
        }
    }
};
class Observer3 : public Observer
{
    void handle(int msgid)
    {
        switch (msgid)
        {
        case 1:
            cout << "observer3 recv 1 msg." << endl;
            break;
        case 3:
            cout << "observer3 recv 3 msg." << endl;
            break;
        default:
            cout << "observer3 recv unknow msg." << endl;
            break;
        }
    }
};
class Subjects
{
public:
    // 给主题添加观察者对象
    void addObserver(Observer* obser,int msgid)
    {
        // 和下面的操作一致,如果存在msgid为key的情况就直接插入,没有就创建一个并插入
        _submap[msgid].push_back(obser);
        /**
        // 查找map中是否存在有key为msgid的值
        auto it = _submap.find(msgid);
        if(it != _submap.end())
        {
            it->second.push_back(obser);
        }
        else
        {
            list<Observer *> olist;
            olist.push_back(obser);
            _submap.insert(make_pair(msgid, olist));
        }
        */
    }
    // 主题检测发生改变,通知相应的观察者对象处理事件
    void dispatch(int msg)
    {
        auto it = _submap.find(msg);
        if (it != _submap.end())
        {
            for(Observer* pObser:it->second)
            {
                pObser->handle(msg);
            }
        }
    }
private:
    unordered_map<int, list<Observer *>> _submap;
};
int main()
{
    Subjects sub;
    Observer *p1 = new Observer1();
    Observer *p2 = new Observer2();
    Observer *p3 = new Observer3();

    sub.addObserver(p1, 1);
    sub.addObserver(p2, 3);
    sub.addObserver(p3, 1);
    sub.addObserver(p3, 2);
    sub.addObserver(p1, 3);

    sub.dispatch(2);
    
    return 0;
}

适配器模式

适配器模式:让不兼容的接口可以在一起工作。

下方使用C++实现了一个电脑播放投影视频的例子,电脑仅仅支持VGA接口,如何实现HDMI接口转化成VGA来适配电脑使用。也就是如何实现一个VGA和HEMI类的转化接口。

#include <iostream>
#include <string>

using namespace std;

class VGA
{
public:
    virtual void play() = 0;
};
class TV01:public VGA
{
public:
    void play() { cout << "通过VGA接口连接投影仪,进行视频播放!" << endl; }
};

class HDMI
{
public:
    virtual void play() = 0;
};
class TV02 : public HDMI
{
public:
    void play() { cout << "通过HDMI接口连接投影仪,进行视频播放!" << endl; }
};

// 一定要继承原来的类
class VGA2HDMIAdapter:public VGA
{
public:
    VGA2HDMIAdapter(HDMI* p):phdmi(p){}
    void play() { phdmi->play(); }

private:
    HDMI *phdmi;
};
class Computer
{
public:
    // 由于电脑只支持VGA接口,所以该方法的参数也只支持VGA接口的指针/引用
    void playVideo(VGA *pVGA) { pVGA->play(); }
};

int main()
{
    // HDMI和VGA无法进行互相转化,电脑如何使用HDMI的play方法?
    /*
    1、换一个支持HDMI的电脑,也就是对Computer类进行重构,叫做代码重构。
    2、使用一个适配器(转化头),把VGA类转化为HDMI类,叫做添加适配器类。
    */

    Computer computer;
    computer.playVideo(new TV01());
    computer.playVideo(new VGA2HDMIAdapter(new TV02()));

    return 0;
}

装饰器模式

装饰器(decorate)模式和代理模式类似。代理模式也就是定义委托类和代理类继承抽象类,并重写函数方法,通过在代理类中使用委托类的对象调用不同级别代理的方法访问。

装饰器主要是增加现有类的功能,但是添加现有类的一个方法还有一个方法,就是新建一个子类。如果每次新建一个功能都需要新建一个子类的话,那么代码中就会有很多的子类被添加进来。

以下实现了一个汽车装饰类的代码实现:

#include <iostream>
#include <string>

using namespace std;

class Car
{
public:
    virtual void show() = 0;
};
class BMW : public Car
{
public:
    void show() { cout << "这是一辆宝马汽车!有基本配置"; }
};
class Audi : public Car
{
public:
    void show() { cout << "这是一辆奥迪汽车!有基本配置"; }
};
class Benc : public Car
{
public:
    void show() { cout << "这是一辆奔驰汽车!有基本配置"; }
};
// 装饰器
class CarDecorator01 : public Car
{
public:
    CarDecorator01(Car *p) : pCar(p){};
    void show()
    {
        pCar->show();
        cout << ",辅助驾驶";
    }
private: 
    Car *pCar;
};
class CarDecorator02 : public Car
{
public:
    CarDecorator02(Car *p) : pCar(p){};
    void show()
    {
        pCar->show();
        cout << ",自动校正";
    }

private:
    Car *pCar;
};
class CarDecorator03 : public Car
{
public:
    CarDecorator03(Car *p) : pCar(p){};
    void show()
    {
        pCar->show();
        cout << ",车道偏离";
    }

private:
    Car *pCar;
};
int main()
{
    Car *p1 = new CarDecorator01(new BMW());
    p1 = new CarDecorator02(p1);
    p1->show();
    cout << endl;

    Car *p2 = new CarDecorator02(new Audi());
    p2->show();
    cout << endl;

    Car *p3 = new CarDecorator03(new Benc());
    p3->show();
    cout << endl;

    return 0;
}

单例模式

常见的类创建一个对象,便会得到一个新的对象。而单例模式则有些不同。

单例模式:一个类不管创建多少次对象,永远只能得到该类型一个对象的实例。可以查看C++实现MySQL数据库连接池中的线程池获取代码,将线程池定义为静态成员方法和静态成员变量,导致其处于静态变量区,只需要初始化一次。类似的日志模块应该也可以使用单例模式。

饿汉式单例模式:还没有获取实例对象,实例对象就已经产生了。
懒汉式单例模式:唯一的实例对象,直到第一次获取它的时候才产生。

下面介绍了两种单例模式的代码设计,其中提供了两种懒汉式单例模式的示例:

#include <iostream>
#include <string>
#include<mutex>
using namespace std;

// 饿汉式单例模式,线程安全的
class HungrySingleton
{
public:
    // 因为其不能依赖对象,所以要定义成静态成员方法,获取类的唯一实例对象的方法
    static HungrySingleton* getSingleton()
    {
        return &instance;
    }
private:
    // 单例模式,不允许用户new对象,所以需要使用构造函数私有化
    HungrySingleton()
    {

    }
    static HungrySingleton instance;
    // 将拷贝构造函数和赋值操作符重载进行删除,使其不能完成对象创建,只能依赖getSingleton过去唯一的实例化对象
    HungrySingleton& operator=(const HungrySingleton &) = delete;
    HungrySingleton(const HungrySingleton &) = delete;
};
// 类内定义,类外初始化,更多static初始化查看 https://blog.csdn.net/sevenjoin/article/details/81772792
// 静态成员在数据段,在main函数之前就创建了,如果不使用的话,这个资源就浪费了
HungrySingleton HungrySingleton::instance;

mutex lazySingletonMtx;

// 懒汉式单例模式,线程安全的
class LazySingleton
{
public:
    // 因为其不能依赖对象,所以要定义成静态成员方法,获取类的唯一实例对象的方法
    // 可重入函数的概念?一个线程还没执行完,该函数不能被另一个线程执行,也就是线程互斥
    static LazySingleton *getSingleton()
    {   
        if(instance==nullptr)
        {
            lock_guard<mutex> lck(lazySingletonMtx); // 所以多线程环境下需要加锁和双重判断
            /*
            不是线程安全,下面这个instance = new LazySingleton()需要执行-:开辟内存、构造对象、instance赋值
            */
            if(instance==nullptr)
            { 
                // 双重判断,防止两个线程同时进入上层的if判断中
                instance = new LazySingleton();
            }
        }
        return instance;
    }

private:
    // 单例模式,不允许用户new对象,所以需要使用构造函数私有化
    LazySingleton()
    {
    }
    static LazySingleton*volatile instance;
    // 将拷贝构造函数和赋值操作符重载进行删除,使其不能完成对象创建,只能依赖getSingleton过去唯一的实例化对象
    LazySingleton &operator=(const LazySingleton &) = delete;
    LazySingleton(const LazySingleton &) = delete;
};
// 类内定义,类外初始化,更多static初始化查看 https://blog.csdn.net/sevenjoin/article/details/81772792
// 静态成员在数据段,在main函数之前就创建了,如果不使用的话,这个资源就浪费了
LazySingleton*volatile LazySingleton::instance=nullptr;

// 懒汉式单例模式,线程安全的
class LazySingleton2
{
public:
    // 因为其不能依赖对象,所以要定义成静态成员方法,获取类的唯一实例对象的方法
    // 可重入函数的概念?一个线程还没执行完,该函数不能被另一个线程执行,也就是线程互斥
    static LazySingleton2 *getSingleton()
    {
        // 静态对象,运行到这个函数才开始初始化
        // 函数静态局部变量的初始化,在汇编指令上已经自动添加线程互斥指令
        static LazySingleton2 instance;
        return &instance;
    }

private:
    // 单例模式,不允许用户new对象,所以需要使用构造函数私有化
    LazySingleton2()
    {
    }
    // 将拷贝构造函数和赋值操作符重载进行删除,使其不能完成对象创建,只能依赖getSingleton过去唯一的实例化对象
    LazySingleton2 &operator=(const LazySingleton2 &) = delete;
    LazySingleton2(const LazySingleton2 &) = delete;
};


int main()
{
    HungrySingleton *p1 = HungrySingleton::getSingleton();
    HungrySingleton *p2 = HungrySingleton::getSingleton();
    HungrySingleton *p3 = HungrySingleton::getSingleton();
    cout << p1 << " " << p2 << " " << p3 << endl; // 0x407030 0x407030 0x407030

    LazySingleton *p4 = LazySingleton::getSingleton();
    LazySingleton *p5 = LazySingleton::getSingleton();
    LazySingleton *p6 = LazySingleton::getSingleton();
    cout << p4 << " " << p5 << " " << p6 << endl; // 0x25d2430 0x25d2430 0x25d2430

    // HungrySingleton t = *p1; // 拷贝构造函数私有化之后就不能完成拷贝构造了

    return 0;
}

一般情况下第二种懒汉式单例模式用的比较多,也更简单,在静态成员方法中定义静态成员对象。

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

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

《重构的时机和方法》——让你的代码更健壮、更易维护

&#x1f44f;作者简介&#xff1a;大家好&#xff0c;我是爱敲代码的小黄&#xff0c;独角兽企业的Java开发工程师&#xff0c;CSDN博客专家&#xff0c;阿里云专家博主&#x1f4d5;系列专栏&#xff1a;Java设计模式、Spring源码系列、Netty源码系列、Kafka源码系列、JUC源码…

微服务体系<1>

我们的微服务架构 我们的微服务架构和单体架构的区别 什么是微服务架构 微服务就是吧我们传统的单体服务分成 订单模块 库存模块 账户模块单体模块 是本地调用 从订单模块 调用到库存模块 再到账户模块 这三个模块都是调用的同一个数据库 这就是我们的单体架构微服务 就是…

8.docker仓库

文章目录 Docker仓库本地私有仓库Docker HarborDocker harbor部署访问页面创建用户下载私有仓库镜像harbor同步 Docker仓库 本地私有仓库 ##先下载 registry 镜像docker pull registry##修改配置文件&#xff0c;在 daemon.json 文件中添加私有镜像仓库地址vim /etc/dock…

Windows使用Notepad++编辑Linux服务器的文件

&#x1f680; Windows使用Notepad编辑Linux服务器的文件 &#x1f680; &#x1f332; 算法刷题专栏 | 面试必备算法 | 面试高频算法 &#x1f340; &#x1f332; 越难的东西,越要努力坚持&#xff0c;因为它具有很高的价值&#xff0c;算法就是这样✨ &#x1f332; 作者简介…

Verilog语法学习——LV2_异步复位的串联T触发器

LV2_异步复位的串联T触发器 题目来源于牛客网 [牛客网在线编程_Verilog篇_Verilog快速入门 (nowcoder.com)](https://www.nowcoder.com/exam/oj?page1&tabVerilog篇&topicId301) 题目 题目描述&#xff1a; 用verilog实现两个串联的异步复位的T触发器的逻辑&#x…

Mac 安装启动RabbitMq

使用HomeBrew安装 未安装的请参照我的这篇Mac安装HomeBrew文章 安装 执行命令 brew install rabbitmq启动方式 brew services start rabbitmq端口说明 端口用处5672RabbitMQ通讯端口&#xff0c;也就是连接使用的端口15672RabbbitMQ管理界面端口&#xff0c;需要开启Manage…

Django实现音乐网站 ⑴

使用Python Django框架制作一个音乐网站。 目录 网站功能模块 安装django 创建项目 创建应用 注册应用 配置数据库 设置数据库配置 设置pymysql库引用 创建数据库 创建数据表 生成表迁移文件 执行表迁移 后台管理 创建管理员账户 启动服务器 登录网站 配置时区…

图技术在 LLM 下的应用:知识图谱驱动的大语言模型 Llama Index

LLM 如火如荼地发展了大半年&#xff0c;各类大模型和相关框架也逐步成型&#xff0c;可被大家应用到业务实际中。在这个过程中&#xff0c;我们可能会遇到一类问题是&#xff1a;现有的哪些数据&#xff0c;如何更好地与 LLM 对接上。像是大家都在用的知识图谱&#xff0c;现在…

web APIs-练习一

轮播图点击切换&#xff1a; <!DOCTYPE html> <html lang"en"><head><meta charset"UTF-8" /><meta http-equiv"X-UA-Compatible" content"IEedge" /><meta name"viewport" content"…

浅谈自动化测试

谈谈那些实习测试工程师应该掌握的基础知识&#xff08;一&#xff09;_什么时候才能变强的博客-CSDN博客https://blog.csdn.net/qq_17496235/article/details/131839453谈谈那些实习测试工程师应该掌握的基础知识&#xff08;二&#xff09;_什么时候才能变强的博客-CSDN博客h…

无涯教程-jQuery - Puff方法函数

吹气效果可以与show/hide/toggle一起使用。通过按比例放大元素并同时隐藏它&#xff0c;可以形成粉扑效果。 Puff - 语法 selector.hide|show|toggle( "puff", {arguments}, speed ); 这是所有参数的描述- model - 效果的模式。可以是"显…

【项目】轻量级HTTP服务器

文章目录 一、项目介绍二、前置知识2.1 URI、URL、URN2.2 CGI2.2.1 CGI的概念2.2.2 CGI模式的实现2.2.3 CGI的意义 三、项目设计3.1 日志的编写3.2 套接字编写3.3 HTTP服务器实现3.4 HTTP请求与响应结构3.5 EndPoint类的实现3.5.1 EndPoint的基本逻辑3.5.2 读取请求3.5.3 构建响…

iOS开发-聊天emoji表情与自定义动图表情左右滑动控件

iOS开发-聊天emoji表情与自定义动图表情左右滑动控件 之前开发中遇到需要实现聊天emoji表情与自定义动图表情左右滑动控件。使用UICollectionView实现。 一、效果图 二、实现代码 UICollectionView是一种类似于UITableView但又比UITableView功能更强大、更灵活的视图&#x…

Debian9离线安装docker

1. 前言 在服务器禁止外网访问的情况下&#xff0c;无法通过apt-get install安装docker&#xff0c;使得docker安装变得异常曲折 本地下载安装包&#xff0c;scp到服务器通过dpkg -i 手动安装&#xff0c;启动docker服务失败… … 各种坑&#xff0c;猛男也要落泪 &#x1f92…

招商银行秋招攻略和考试内容详解

招商银行秋招简介 招商银行是一家股份制商业银行&#xff0c;银行的服务理念已经深入人心&#xff0c;在社会竞争愈来愈烈的今天&#xff0c;招商银行的招牌无疑是个香饽饽&#xff0c;很多人也慕名而至&#xff0c;纷纷向招商银行投出了简历。那么秋招银行的秋招开始时间是多…

VMware虚拟机安装VMware tools

一、挂载光驱 执行以下命令来创建 /mnt/cdrom 目录&#xff1a; mkdir -p /mnt/cdrom-p 参数会确保如果 /mnt/cdrom 的上级目录&#xff08;例如 /mnt&#xff09;不存在的话也会被创建。 然后&#xff0c;你可以再次尝试挂载光盘&#xff1a; mount /dev/sr0 /mnt/cdrom这次…

面试手写实现Promise.all

目录 前言常见面试手写系列Promise.resolve 简要回顾源码实现Promise.reject 简要回顾源码实现Promise.all 简要回顾源码实现Promise.allSettled 简要回顾源码实现Promise.race 简单回顾源码实现结尾 前言 (?﹏?)曾经真实发生在一个朋友身上的真实事件&#xff0c;面试官让…

flink采用thrift读取tablets一个天坑

原先的配置 [INFO] StarRocksSourceBeReader [open Scan params.mem_limit 8589934592 B] [INFO] StarRocksSourceBeReader [open Scan params.query-timeout-s 600 s] [INFO] StarRocksSourceBeReader [open Scan params.keep-alive-min 100 min] [INFO] StarRocksSourceBeRea…

软件外包开发测试管理工具

测试是软件工程中非常重要的一个环节&#xff0c;在上线前必须需要经过严格的测试才能确保上线后软件系统长时间运行。有大量的软件开发和测试管理工具&#xff0c;每一个工具都有自己的特点&#xff0c;今天和大家分享一些常见的工具&#xff0c;希望对大家有所帮助。北京木奇…

MySQL中锁的简介——行级锁之 间隙锁 和 临键锁

1.间隙锁演示 2.临键锁演示 间隙锁锁住的是间隙&#xff0c;不包含对应的数据记录&#xff0c;而临键锁既会包含当前这条数据记录&#xff0c;也会锁定该数据记录之前的间隙。间隙锁的目的是防止其他事务插入间隙造成幻读现象。间隙锁是可以共存的&#xff0c;一个事务采用的间…