设计模式.

设计模式

  • 一、介绍
  • 二、六大原则
    • 1、单一职责原则（Single Responsibility Principle, SRP）
    • 2、开闭原则（Open-Closed Principle, OCP）
    • 3、里氏替换原则（Liskov Substitution Principle, LSP）
    • 4、接口隔离原则（Interface Segregation Principle, ISP）
    • 5、依赖倒置原则（Dependency Inversion Principle, DIP）
    • 6、迪米特法则（Law of Demeter, LoD）
  • 三、单例模式
    • 1、介绍
    • 2、模式
    • 3、示例
      • （1）饿汉模式
      • （2）懒汉模式
  • 四、工厂模式
    • 1、介绍
    • 2、实现方式
    • 3、示例
  • 五、建造者模式
    • 1、介绍
    • 2、实现方式
    • 3、示例
  • 六、代理模式
    • 1、介绍
    • 2、主要角色
    • 3、示例

一、介绍

  • 设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。它旨在使代码更加可重用、易于理解和维护，并提高代码的可靠性。

二、六大原则

1、单一职责原则（Single Responsibility Principle, SRP）

  • 一个类应该只有一个引起它变化的原因，即一个类只负责一项功能或职责。
  • 如果一个类承担的职责过多，就等于把这些职责耦合在一起，一个职责的变化可能会削弱或抑制该类完成其他职责的能力。因此，将类的职责分离到不同的类中，可以提高代码的可读性、可维护性和可扩展性。

2、开闭原则（Open-Closed Principle, OCP）

  • 软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。
  • 当需要增加新功能时，应该通过扩展已有的软件实体来实现，而不是修改已有的代码。这可以通过使用接口、抽象类或组合/聚合等方式来实现。

3、里氏替换原则（Liskov Substitution Principle, LSP）

  • 子类必须能够替换其基类而不会引起程序行为的改变。
  • 在软件设计中，应优先使用对象组合而不是类继承，以避免破坏基类已有的功能。子类应该实现父类的抽象方法，但不得重写父类的非抽象方法。子类可以增加自己特有的方法，并且子类方法的前置条件（输入参数）应该比父类方法的输入参数类型更宽松，方法的后置条件（返回值）应该比父类返回值类型更严格。

4、接口隔离原则（Interface Segregation Principle, ISP）

  • 客户端不应该依赖它不需要的接口，即使用多个隔离的接口比使用单个的接口好。
  • 一个接口应该只包含客户感兴趣的方法，而不是将所有可能的方法都放在一个接口中。这样可以降低类之间的耦合度，便于维护。

5、依赖倒置原则（Dependency Inversion Principle, DIP）

  • 高层模块不应该依赖于低层模块，两者都应该依赖于抽象。抽象不应该依赖于细节，细节应该依赖于抽象。
  • 这意味着我们应该通过抽象层（如接口或抽象类）来定义模块间的依赖关系，而不是直接依赖具体的实现类。依赖倒置原则本质上就是面向接口编程，它提高了系统的灵活性和可扩展性。

6、迪米特法则（Law of Demeter, LoD）

  • 一个实体应该尽量少的与其他实体发生相互作用，使得系统功能模块相对独立。
  • 迪米特法则也称为最少知道原则，它要求一个类应该尽量少的了解其他类的内部细节，只与必要的类进行交互。这样可以降低系统的复杂性，提高系统的可维护性和可扩展性。

三、单例模式

1、介绍

  • 单例模式（Singleton Pattern）是一种创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点来获取该实例。在需要控制资源访问、实现全局状态管理、或者在整个应用程序生命周期中需要保持某些对象唯一性的场景中非常有用。
关键点作用
私有构造函数防止外部通过 new 关键字创建实例
静态实例变量用于存储类的唯一实例
公共静态方法提供一个全局访问点来获取实例
删除拷贝构造和赋值运算符重载防止创建多个实例和对象间的赋值操作

2、模式

懒汉模式饿汉模式
创建时机第一次访问时类加载时
线程安全不安全，需要使用同步锁等方式来确保线程安全线程安全
优点延迟加载，节省资源实现简单，线程安全
缺点实现复杂，线程不安全无论是否需要使用都会占用资源，可能导致资源浪费

3、示例

（1）饿汉模式

#include <iostream>

class Singleton
{
private:
    static Singleton _eton;

private:
    Singleton() : _data(666) {  std::cout << "单例Singleton 饿汉, 构造函数" << std::endl;  };
    ~Singleton() {};
    Singleton(const Singleton &) = delete;
    Singleton &operator=(const Singleton &) = delete;

private:
    int _data;

public:
    static Singleton &getInstance()
    {
        return _eton;
    }

    int getData()
    {
        return _data;
    }
};

Singleton Singleton::_eton;

int main()
{
    std::cout << Singleton::getInstance().getData() <<std::endl;
    return 0;
}

在这里插入图片描述

（2）懒汉模式

class Singleton
{
private:
    Singleton() : _data(666) {  std::cout << "单例Singleton 懒汉, 构造函数" << std::endl;  };
    ~Singleton() {};
    Singleton(const Singleton &) = delete;
    Singleton &operator=(const Singleton &) = delete;

private:
    int _data;

public:
    static Singleton &getInstance()
    {
        static Singleton _eton;
        return _eton;
    }

    int getData()
    {
        return _data;
    }
};
  • 上方代码在C++11后才是线程安全的，因为C++11局部的静态变量的创建是线程安全的。

四、工厂模式

1、介绍

  • 工厂模式（Factory Pattern）是一种创建型设计模式，它旨在定义一个用于创建对象的接口，但让子类决定实例化哪一个类。工厂模式让类的实例化推迟到其子类。这样可以将对象的实例化与客户端代码的耦合度降到最低，同时也提供了一种可扩展的方式来创建对象。
主要角色作用
抽象产品（AbstractProduct）定义产品的接口，是工厂方法模式所创建对象的公共父类
具体产品（ConcreteProduct）实现了抽象产品接口，某种类型的具体产品由专门的具体工厂创建
抽象工厂（AbstractFactory）在抽象工厂类中声明了工厂方法，用于返回一个产品。抽象工厂是工厂方法模式的核心，所有创建对象的工厂类都必须实现该接口
具体工厂（ConcreteFactory）实现了抽象工厂中声明的工厂方法，并可由客户端调用，返回一个具体产品类的实例

2、实现方式

  • 简单工厂模式（Simple Factory Pattern）：通过一个工厂类来创建对象，客户端通过传递不同的参数给工厂类，工厂类根据参数的不同来创建不同的对象实例。优点是客户端代码简单，隐藏了具体对象的创建细节；缺点是当需要添加新的产品时，需要修改工厂类的代码，违反了开闭原则。
  • 工厂方法模式（Factory Method Pattern）：将对象的创建延迟到子类中去实现，即定义一个创建对象的接口，但让子类决定实例化哪个类。客户端通过调用工厂方法来创建对象，具体的实例化过程由子类负责。这样可以解决简单工厂模式中的缺点，使得系统更具灵活性和可扩展性。
  • 抽象工厂模式（Abstract Factory Pattern）：提供一个接口用于创建一系列相关或依赖对象的家族，而不需要指定具体的类。与工厂方法模式相比，抽象工厂模式是针对多个产品等级结构的，可以创建不同产品族的全部产品。这种模式适用于需要在运行时切换不同产品族的场景，但增加新的产品族往往不太容易。

3、示例

  • 简单工厂模式
#include <iostream>
#include <memory>
#include <string>

class Fruit
{
public:
    virtual void name() = 0;
};

class Apple : public Fruit
{
public:
    void name() override
    {
        std::cout << "i am a apple" << std::endl;
    }
};

class Pineapple : public Fruit
{
public:
    void name() override
    {
        std::cout << "i am a pineapple" << std::endl;
    }
};

class FruitFactory
{
public:
    static std::shared_ptr<Fruit> create(const std::string& name)
    {
        if(name == "apple")
            return std::make_shared<Apple>();
        else if(name == "pineapple")
            return std::make_shared<Pineapple>();
        return std::shared_ptr<Fruit>();
    }
};

int main()
{
    std::shared_ptr<Fruit> fruit = FruitFactory::create("apple");
    fruit->name();
    fruit.reset();
    fruit = FruitFactory::create("pineapple");
    fruit->name();
    return 0;
}

在这里插入图片描述

  • 工厂方法模式
class Factory
{
public:
    virtual std::shared_ptr<Fruit> create() = 0;
};

class AppleFactory : public Factory
{
public:
    std::shared_ptr<Fruit> create()
    {
        return std::make_shared<Apple>();
    }
};

class PineappleFactory : public Factory
{
public:
    std::shared_ptr<Fruit> create()
    {
        return std::make_shared<Pineapple>();
    }
};

int main()
{
    std::shared_ptr<Factory> fruitFactory(new AppleFactory());
    std::shared_ptr<Fruit> fruit = fruitFactory->create();
    fruit->name();
    fruitFactory.reset(new PineappleFactory());
    fruit = fruitFactory->create();
    fruit->name();

    return 0;
}

在这里插入图片描述

  • 抽象工厂模式
class Animal
{
public:
    virtual void voice() = 0;
};

class Dragon : public Animal
{
public:
    void voice() override
    {
        std::cout << "恶龙咆哮" << std::endl;
    }
};

class Wolf : public Animal
{
public:
    void voice() override
    {
        std::cout << "我一定会回来的" << std::endl;
    }
};


class Factory
{
public:
    virtual std::shared_ptr<Fruit> getFruit(const std::string& name) = 0;
    virtual std::shared_ptr<Animal> getAnimal(const std::string& name) = 0;
};

class FruitFactory : public Factory
{
public:
    std::shared_ptr<Fruit> getFruit(const std::string& name) override
    {
        if(name == "apple")
            return std::make_shared<Apple>();
        else if(name == "pineapple")
            return std::make_shared<Pineapple>();
        return std::shared_ptr<Fruit>();        // 需用shared_ptr
    }

    std::shared_ptr<Animal> getAnimal(const std::string& name)  override
    {
        return std::shared_ptr<Animal>();        // 需用shared_ptr
    }
};

class AnimalFactory : public Factory
{
public:
    std::shared_ptr<Fruit> getFruit(const std::string& name)  override
    {
        return std::shared_ptr<Fruit>();
    }

    std::shared_ptr<Animal> getAnimal(const std::string& name) override
    {
        if(name == "dragon")
            return std::make_shared<Dragon>();
        else if(name == "wolf")
            return std::make_shared<Wolf>();
        return std::shared_ptr<Animal>();
    }
};

class FactoryProducer
{
public:
    static std::shared_ptr<Factory> getFactory(const std::string& name)     // 可以声明为静态，这样调用时就不用创建对象
    {
        if(name == "fruit")
            return std::make_shared<FruitFactory>();
        else if(name == "animal")
            return std::make_shared<AnimalFactory>();
        return std::shared_ptr<Factory>();
    }
};


int main()
{
    std::shared_ptr<Factory> factory = FactoryProducer::getFactory("fruit");
    std::shared_ptr<Fruit> fruit = factory->getFruit("apple");
    fruit->name();
    fruit.reset();
    fruit = factory->getFruit("pineapple");
    fruit->name();
    std::cout << "\n";

    factory = FactoryProducer::getFactory("animal");
    std::shared_ptr<Animal> animal = factory->getAnimal("dragon");
    animal->voice();
    animal.reset();
    animal = factory->getAnimal("wolf");
    animal->voice();

    return 0;
}

在这里插入图片描述

五、建造者模式

1、介绍

  • 建造者模式（Builder Pattern）是一种创建型设计模式，它将一个复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。该模式允许用户通过指定复杂对象的类型和内容来构建它们，而无需知道内部的具体构建细节。
  • 建造者模式的目的是将对象的构建过程拆分成多个简单的步骤，并允许用户通过调用这些步骤来逐步构建对象。
主要角色说明
产品（Product）要创建的复杂对象
抽象建造者（Builder）定义一个用于创建和装配产品各个部件的抽象接口
具体建造者（ConcreteBuilder）实现抽象建造者接口，并构建和装配具体产品的各个部件。同时，它还提供一个方法来返回最终创建的产品
指挥者（Director）构造一个使用抽象建造者接口的对象。它主要用于创建一个复杂对象，并控制其构建过程。指挥者并不与具体的产品类发生关系，而是通过一个抽象建造者接口来间接创建产品
  • 与工厂模式的区别：建造者模式与工厂模式在创建对象方面有所不同。工厂模式主要用于创建具有共同接口或基类的不同实例，而建造者模式则更关注于对象的复杂构建过程和各个部件的组装。

2、实现方式

  • 在建造者模式中，通常会有一个具体的产品类，该类包含了产品的各个属性和方法。然后，会有一个或多个具体建造者类，这些类实现了抽象建造者接口，并提供了构建产品各个部件的方法。指挥者类则负责调用这些方法来逐步构建产品。

3、示例

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

class Computer
{
public:
    void setBoard(const std::string& board)       // 派生类不重写，不要加virtual
    {
        _board = board;             // 没加virtual，需要对成员变量进行赋值
    }
    void setDisplay(const std::string& display)
    {
        _display = display;
    }
    virtual void setOs() = 0;

    std::string show()
    {
        // std::cout<<_board<<" "<<_display<<std::endl;
        std::string comp = "computer:\n ";          // 换行之和多加一个空格，否则下一句中文可能乱码
        comp += "\tboard: " + _board + " \n ";
        comp += "\tdisplay: " + _display + "\n ";
        comp += "\tos: " + _os + "\n";
        // std::cout << comp << std::endl;
        return comp;
    }
protected:
    std::string _board;
    std::string _display;
    std::string _os;
};

class Legion : public Computer
{
public:
    void setOs()
    {
        _os = "Windows 11";
    }
};

class Builder
{
public:
    virtual void buildBoard(const std::string& board) = 0;
    virtual void buildDisplay(const std::string& display) = 0;
    virtual void buildOs() = 0;     // os也需要调用
    virtual std::shared_ptr<Computer> build() = 0;
};

class LegionBuilder : public Builder
{
public:
    LegionBuilder():_cp(new Legion()){}         // 构造对象
    void buildBoard(const std::string& board)
    {
        _cp->setBoard(board);
    }

    void buildDisplay(const std::string& display)
    {
        _cp->setDisplay(display);
    }

    void buildOs()
    {
        _cp->setOs();
    }

    std::shared_ptr<Computer> build()
    {
        return _cp;
    }

private:
    std::shared_ptr<Computer> _cp;        // 类型需要是Computer
};

class Direct
{
public:
    Direct(Builder* bp):_bp(bp){}

    void construct(const std::string& board, const std::string& display)
    {
        _bp->buildBoard(board);
        _bp->buildDisplay(display);
        _bp->buildOs();
    }
private:
    std::shared_ptr<Builder> _bp;
};

int main()
{
    Builder* bp = new LegionBuilder();
    std::unique_ptr<Direct> dup(new Direct(bp));
    dup->construct("联想", "三星");
    std::shared_ptr<Computer> cp = bp->build();
    std::cout << cp->show();
    // cp->show();

    return 0;
}

在这里插入图片描述

六、代理模式

1、介绍

  • 代理模式（Proxy Pattern）是程序设计中的一种结构型设计模式，其为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。
  • 代理模式的目的是在不修改目标对象代码的前提下，通过代理对象来控制对目标对象的访问，并增加额外的功能或提供间接访问。

2、主要角色

  • 抽象主题（Subject）：声明了真实主题和代理主题的共同接口，这样一来在任何使用真实主题的地方都可以使用代理主题。
  • 真实主题（RealSubject）：实现了抽象主题接口，是真正执行任务的对象。
  • 代理主题（Proxy）：代理主题角色内部含有对真实主题的引用，从而可以在任何时候操作真实主题对象；代理主题角色提供一个与真实主题角色相同的接口，以便可以在任何时候都可以替代真实主题；控制真实主题的应用，负责在需要的时候创建真实主题对象（和删除真实主题对象）。代理角色通常在将客户端调用传递给真实的主题之前或之后，都要执行某个操作，而不是单纯的将调用传递给真实主题对象。

3、示例

#include <iostream>

class RentHouse
{
public:
    virtual void rentHouse() = 0;
};

class Landlord : public RentHouse
{
public:
    void rentHouse()
    {
        std::cout << "Landlord rent the house" << std::endl;
    }
};

class Intermediary : public RentHouse
{
public:
    void rentHouse()
    {
        std::cout << "发布租房起始" << std::endl;
        std::cout << "带领租客看房" << std::endl;
        _ld.rentHouse();
        std::cout << "后期维修相关" << std::endl;
    }
private:
    Landlord _ld;
};

int main()
{
    Intermediary im;
    im.rentHouse();

    return 0;
}

在这里插入图片描述

本文到这里就结束了，如有错误或者不清楚的地方欢迎评论或者私信
本文只是在编写项目，学习过程中所做的总结，不会涉及过深的概念
创作不易，如果觉得博主写得不错，请点赞、收藏加关注支持一下💕💕💕

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

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

相关文章

STM32的HAL库开发-通用定时器输入捕获实验

STM32的HAL库开发-通用定时器输入捕获实验

一、通用定时器输入捕获部分框图介绍 1、捕获/比较通道的输入部分(通道1) 首先设置 TIM_CCMR1的CC1S[1:0]位&#xff0c;设置成01&#xff0c;那么IC1来自于TI1&#xff0c;也就是说连接到TI1FP1上边。设置成10&#xff0c;那个IC1来自于TI2&#xff0c;连接到TI2FP1上。设置成…
阅读更多...
JavaScript 复习

JavaScript 复习

文章目录 语法前置语法组成引入位置内部引入外部引入 基础语法输出变量变量声明规则变量赋值变量的作用范围 数据类型强制类型转换强转为 Number强转为 Boolean强转为 String强转为 整数 | 浮点数 运算符流程控制隐式转换函数常用内置对象String 对象Array 数组对象Math 数学对…
阅读更多...
【C】链表算法题5 -- 相交链表

【C】链表算法题5 -- 相交链表

leetcode链接https://leetcode.cn/problems/intersection-of-two-linked-lists/description/https://leetcode.cn/problems/intersection-of-two-linked-lists/description/ 题目描述 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节…
阅读更多...
蓝桥杯准备 【入门3】循环结构

蓝桥杯准备 【入门3】循环结构

素数小算法&#xff08;埃氏筛&&欧拉筛&#xff09; 以下四段代码都是求20以内的所有素数 1.0版求素数 #include<iostream> using namespace std;int main() {int n 20;for(int i2;i<n;i){int j0;for(j2;j<i;j)//遍历i{if(i%j0){break;}}if(ij){cout&l…
阅读更多...
寒假2.6--SQL注入之布尔盲注

寒假2.6--SQL注入之布尔盲注

知识点 原理&#xff1a;通过发送不同的SQL查询来观察应用程序的响应&#xff0c;进而判断查询的真假&#xff0c;并逐步推断出有用的信息 适用情况&#xff1a;一个界面存在注入&#xff0c;但是没有显示位&#xff0c;没有SQL语句执行错误信息&#xff0c;通常用于在无法直接…
阅读更多...
Servlet笔记（下）

Servlet笔记（下）

HttpServletRequest对象相关API 获取请求行信息相关(方式,请求的url,协议及版本) | API | 功能解释 | | ----------------------------- | ------------------------------ | | StringBuffer getRequestURL(); | 获取客户端…
阅读更多...
QQ自动发送消息

QQ自动发送消息

QQ自动发送消息 python包导入 import time import pandas as pd import pyautogui import pyperclip图像识别函数封装 本程序使用pyautogui模块控制鼠标和键盘来实现QQ自动发送消息&#xff0c;因此必须得到需要点击位置的坐标&#xff08;当然也可以在程序中将位置写死&…
阅读更多...
5.1计算机网络基本知识

5.1计算机网络基本知识

5.1.1计算机网络概述 目前&#xff0c;三网融合(电信网络、有线电视网络和计算机网络)和宽带化是网络技术的发展的大方向&#xff0c;其应用广泛&#xff0c;遍及智能交通、环境保护、政府工作、公共安全、平安家居等多个领域&#xff0c;其中发展最快的并起到核心作用的则是计…
阅读更多...
51单片机之冯·诺依曼结构

51单片机之冯·诺依曼结构

一、概述 8051系列单片机将作为控制应用最基本的内容集成在一个硅片上&#xff0c;其内部结构如图4-1所示。作为单一芯片的计算机&#xff0c;它的内部结构与一台计算机的主机非常相似。其中微处理器相当于计算机中的CPU&#xff0c;由运算器和控制器两个部分构成&#xff1b;…
阅读更多...
13.PPT：诺贝尔奖【28】

13.PPT：诺贝尔奖【28】

目录 NO1234 NO567 NO8/9/10 NO11/12 NO1234 设计→变体→字体→自定义字体 SmartArt超链接新增加节 NO567 版式删除图片中的白色背景&#xff1a;选中图片→格式→删除背景→拖拉整个图片→保留更改插入→图表→散点图 &#xff1a;图表图例、网格线、坐标轴和图表标题…
阅读更多...
RabbitMQ 从入门到精通：从工作模式到集群部署实战（一）

RabbitMQ 从入门到精通：从工作模式到集群部署实战（一）

#作者&#xff1a;闫乾苓 文章目录 RabbitMQ简介RabbitMQ与VMware的关系架构工作流程RabbitMQ 队列工作模式及适用场景简单队列模式&#xff08;Simple Queue&#xff09;工作队列模式&#xff08;Work Queue&#xff09;发布/订阅模式&#xff08;Publish/Subscribe&#xff…
阅读更多...
DFX（Design for eXcellence）架构设计全解析：理论、实战、案例与面试指南*

DFX（Design for eXcellence）架构设计全解析：理论、实战、案例与面试指南*

一、什么是 DFX &#xff1f;为什么重要&#xff1f; DFX&#xff08;Design for eXcellence&#xff0c;卓越设计&#xff09;是一种面向产品全生命周期的设计理念&#xff0c;旨在确保产品在设计阶段就具备**良好的制造性&#xff08;DFM&#xff09;、可测试性&#xff08;…
阅读更多...
【Elasticsearch】diversified sampler

【Elasticsearch】diversified sampler

作用就是聚合前的采样&#xff0c;主要是采样 它就是用来采样的&#xff0c;采完样后在进行聚合操作 random_sampler和diversified_sampler是 Elasticsearch 中用于聚合查询的两种采样方法&#xff0c;它们的主要区别如下&#xff1a; 采样方式 • random_sampler&#xff1a…
阅读更多...
2月7号.

2月7号.

二叉树是一种特殊的树形数据结构&#xff0c;具有以下特点&#xff1a; 基本定义 节点的度&#xff1a;二叉树中每个节点最多有两个子节点&#xff0c;分别称为左子节点和右子节点。 子树的顺序性&#xff1a;二叉树的子树有左右之分&#xff0c;且顺序不能颠倒。 递归定义&…
阅读更多...
openpnp2.2 - 环境搭建 - 编译 + 调试 + 打包

openpnp2.2 - 环境搭建 - 编译 + 调试 + 打包

文章目录 openpnp2.2 - 环境搭建 - 编译 调试 打包概述笔记前置任务克隆代码库切到最新的tag清理干净编译工程关掉旧工程打开已经克隆好的openpnp2.2工程将IDEA的SDK配置为openjdk23 切换中英文UI设置JAVA编译器 构建工程跑测试用例单步调试下断点导出工程的JAR包安装install…
阅读更多...
【复现论文】DAVE

【复现论文】DAVE

网站&#xff1a; GitHub - jerpelhan/DAVE 下载完以后&#xff0c;阅读 readme文件 新建终端&#xff0c;打印文件树&#xff0c;不包含隐藏文件&#xff1a; 命令&#xff1a;tree -I .* . ├── LICENSE ├── README.md ├── demo.py ├── demo_zero.py ├── mai…
阅读更多...
GB/T28181 开源日记[8]：国标开发速知速会

GB/T28181 开源日记[8]：国标开发速知速会

服务端源代码 github.com/gowvp/gb28181 前端源代码 github.com/gowvp/gb28181_web 介绍 go wvp 是 Go 语言实现的开源 GB28181 解决方案&#xff0c;基于GB28181-2022标准实现的网络视频平台&#xff0c;支持 rtmp/rtsp&#xff0c;客户端支持网页版本和安卓 App。支持rts…
阅读更多...
完美解决phpstudy安装后mysql无法启动

完美解决phpstudy安装后mysql无法启动

phpstudy数据库无法启动有以下几个原因。 **一、**自己在电脑上安装了MySQL数据库,MySQL的服务名为MySQL,这会与phpstudy的数据库的服务名发生冲突&#xff0c;从而造成phpstudy中的数据库无法启动&#xff0c;这时我们只需要将自己安装的MySQL的服务名改掉就行。 但是&#…
阅读更多...
grafana面板配置opentsdb

grafana面板配置opentsdb

新增面板&#xff1a; 这里add-panel: 如果不是想新增面板而是想新增一行条目&#xff0c;则点击convert to row: 在新增的面板这里可以看到选择数据源 Aggregator&#xff1a;聚合条件&#xff0c;区分下第一行和第二行的aggregator&#xff0c;第一个是对指标值的聚合&…
阅读更多...
论文翻译学习：《DeepSeek-R1: 通过强化学习激励大型语言模型的推理能力》

论文翻译学习：《DeepSeek-R1: 通过强化学习激励大型语言模型的推理能力》

摘要 我们介绍了我们的第一代推理模型 DeepSeek-R1-Zero 和 DeepSeek-R1。DeepSeek-R1-Zero 是一个通过大规模强化学习&#xff08;RL&#xff09;训练的模型&#xff0c;没有经过监督微调&#xff08;SFT&#xff09;作为初步步骤&#xff0c;展示了卓越的推理能力。通过强化…
阅读更多...
最新文章

Copyright @ 2022~2023