设计模式3-分类

设计模式-分类

  • 模式的分类
    • 从目的来分
      • 创建型模式（Creational Patterns）
      • 结构型模式（Structural Patterns）
      • 行为型模式（Behavioral Patterns）
    • 从范围来分
      • 类模式（Class Patterns）
      • 对象模式（Object Patterns）
      • 类模式和对象模式的区别
    • 从封装变化角度对模式分类
      • 组件协作
      • 单一职责
      • 对象创建
      • 对象性能
      • 接口隔离
      • 状态变化
      • 数据结构
      • 行为变化
      • 领域问题

模式的分类

从目的来分

设计模式（Design Patterns）是一种解决特定问题的通用解决方案，通常分为以下三类：

  1. 创建型模式（Creational Patterns）：

    • 主要关注对象的创建过程，旨在将对象的创建过程与使用过程分离，以提高代码的灵活性和可维护性。

  2. 结构型模式（Structural Patterns）：

    • 主要关注类和对象的组合，旨在通过不同的方式将类或对象组合在一起，以形成更大的结构，从而解决设计中的一些问题。

  3. 行为型模式（Behavioral Patterns）：

    • 主要关注类和对象之间的交互，旨在通过合理安排类和对象之间的职责和通信方式，来提高系统的灵活性和可扩展性。

创建型模式（Creational Patterns）

  1. 工厂方法模式（Factory Method）：

    • 定义一个接口用于创建对象，但由子类决定实例化哪一个类。使得一个类的实例化延迟到其子类。
    class Product {
public:virtual void use() = 0;
};class ConcreteProductA : public Product {
public:void use() override {// Implementation for Product A}
};class ConcreteProductB : public Product {
public:void use() override {// Implementation for Product B}
};class Creator {
public:virtual Product* createProduct() = 0;
};class ConcreteCreatorA : public Creator {
public:Product* createProduct() override {return new ConcreteProductA();}
};class ConcreteCreatorB : public Creator {
public:Product* createProduct() override {return new ConcreteProductB();}
};

  2. 抽象工厂模式（Abstract Factory）：

    • 提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
    class AbstractProductA {
public:virtual void use() = 0;
};class AbstractProductB {
public:virtual void consume() = 0;
};class ConcreteProductA1 : public AbstractProductA {
public:void use() override {// Implementation for Product A1}
};class ConcreteProductA2 : public AbstractProductA {
public:void use() override {// Implementation for Product A2}
};class ConcreteProductB1 : public AbstractProductB {
public:void consume() override {// Implementation for Product B1}
};class ConcreteProductB2 : public AbstractProductB {
public:void consume() override {// Implementation for Product B2}
};class AbstractFactory {
public:virtual AbstractProductA* createProductA() = 0;virtual AbstractProductB* createProductB() = 0;
};class ConcreteFactory1 : public AbstractFactory {
public:AbstractProductA* createProductA() override {return new ConcreteProductA1();}AbstractProductB* createProductB() override {return new ConcreteProductB1();}
};class ConcreteFactory2 : public AbstractFactory {
public:AbstractProductA* createProductA() override {return new ConcreteProductA2();}AbstractProductB* createProductB() override {return new ConcreteProductB2();}
};

  3. 单例模式（Singleton）：

    • 确保一个类只有一个实例，并提供一个全局访问点。
    class Singleton {
private:static Singleton* instance;Singleton() {}  // Private constructorpublic:static Singleton* getInstance() {if (instance == nullptr) {instance = new Singleton();}return instance;}
};Singleton* Singleton::instance = nullptr;

  4. 生成器模式（Builder）：

    • 将一个复杂对象的构建过程与它的表示分离，使得同样的构建过程可以创建不同的表示。
    class Product {
private:std::string partA;std::string partB;std::string partC;public:void setPartA(const std::string& part) { partA = part; }void setPartB(const std::string& part) { partB = part; }void setPartC(const std::string& part) { partC = part; }void show() {// Implementation to show the product}
};class Builder {
public:virtual void buildPartA() = 0;virtual void buildPartB() = 0;virtual void buildPartC() = 0;virtual Product* getResult() = 0;
};class ConcreteBuilder : public Builder {
private:Product* product;public:ConcreteBuilder() { product = new Product(); }void buildPartA() override { product->setPartA("Part A"); }void buildPartB() override { product->setPartB("Part B"); }void buildPartC() override { product->setPartC("Part C"); }Product* getResult() override { return product; }
};class Director {
private:Builder* builder;public:void setBuilder(Builder* b) { builder = b; }void construct() {builder->buildPartA();builder->buildPartB();builder->buildPartC();}
};

  5. 原型模式（Prototype）：

    • 用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
    class Prototype {
public:virtual Prototype* clone() const = 0;
};class ConcretePrototype : public Prototype {
public:ConcretePrototype* clone() const override {return new ConcretePrototype(*this);}
};

结构型模式（Structural Patterns）

  1. 适配器模式（Adapter）：

    • 将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的类可以一起工作。
    class Target {
public:virtual void request() = 0;
};class Adaptee {
public:void specificRequest() {// Specific implementation}
};class Adapter : public Target {
private:Adaptee* adaptee;public:Adapter(Adaptee* a) : adaptee(a) {}void request() override {adaptee->specificRequest();}
};

  2. 桥接模式（Bridge）：

    • 将抽象部分与它的实现部分分离，使它们都可以独立地变化。
    class Implementor {
public:virtual void operationImpl() = 0;
};class ConcreteImplementorA : public Implementor {
public:void operationImpl() override {// Implementation A}
};class ConcreteImplementorB : public Implementor {
public:void operationImpl() override {// Implementation B}
};class Abstraction {
protected:Implementor* implementor;public:Abstraction(Implementor* impl) : implementor(impl) {}virtual void operation() = 0;
};class RefinedAbstraction : public Abstraction {
public:RefinedAbstraction(Implementor* impl) : Abstraction(impl) {}void operation() override {implementor->operationImpl();}
};

  3. 组合模式（Composite）：

    • 将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。
    class Component {
public:virtual void operation() = 0;virtual void add(Component* component) {}virtual void remove(Component* component) {}virtual Component* getChild(int index) { return nullptr; }
};class Leaf : public Component {
public:void operation() override {// Implementation of leaf node}
};class Composite : public Component {
private:std::vector<Component*> children;public:void operation() override {for (Component* child : children) {child->operation();}}void add(Component* component) override {children.push_back(component);}void remove(Component* component) override {children.erase(std::remove(children.begin(), children.end(), component), children.end());}Component* getChild(int index) override {return children.at(index);}
};

  4. 装饰模式（Decorator）：

    • 动态地给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更为灵活。
    class Component {
public:virtual void operation() = 0;
};class ConcreteComponent : public Component {
public:void operation() override {// Basic implementation}
};class Decorator : public Component {
protected:

行为型模式（Behavioral Patterns）

行为型模式（Behavioral Patterns）关注对象之间的责任分配以及对象之间的通信。它们帮助实现对象之间的灵活通信和职责分配，从而提高系统的可扩展性和可维护性。以下是一些常见的行为型设计模式及其 C++ 示例：

  1. 策略模式（Strategy Pattern）
  2. 观察者模式（Observer Pattern）
  3. 命令模式（Command Pattern）
  4. 职责链模式（Chain of Responsibility Pattern）
  5. 状态模式（State Pattern）

1. 策略模式（Strategy Pattern）

策略模式定义了算法家族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化不会影响使用算法的客户。

示例代码：

#include <iostream>
#include <memory>// 策略接口
class Strategy {
public:virtual void execute() const = 0;
};// 具体策略A
class ConcreteStrategyA : public Strategy {
public:void execute() const override {std::cout << "Executing Strategy A" << std::endl;}
};// 具体策略B
class ConcreteStrategyB : public Strategy {
public:void execute() const override {std::cout << "Executing Strategy B" << std::endl;}
};// 上下文类
class Context {
private:std::unique_ptr<Strategy> strategy;
public:void setStrategy(std::unique_ptr<Strategy> strategy) {this->strategy = std::move(strategy);}void executeStrategy() const {strategy->execute();}
};int main() {Context context;context.setStrategy(std::make_unique<ConcreteStrategyA>());context.executeStrategy();context.setStrategy(std::make_unique<ConcreteStrategyB>());context.executeStrategy();return 0;
}

2. 观察者模式（Observer Pattern）

观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。当主题对象的状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

示例代码：

#include <iostream>
#include <vector>
#include <memory>// 观察者接口
class Observer {
public:virtual void update(int state) = 0;
};// 具体观察者
class ConcreteObserver : public Observer {
private:std::string name;
public:ConcreteObserver(const std::string& name) : name(name) {}void update(int state) override {std::cout << "Observer " << name << " updated with state " << state << std::endl;}
};// 主题接口
class Subject {
public:virtual void attach(std::shared_ptr<Observer> observer) = 0;virtual void detach(std::shared_ptr<Observer> observer) = 0;virtual void notify() = 0;
};// 具体主题
class ConcreteSubject : public Subject {
private:std::vector<std::shared_ptr<Observer>> observers;int state;
public:void attach(std::shared_ptr<Observer> observer) override {observers.push_back(observer);}void detach(std::shared_ptr<Observer> observer) override {observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end());}void notify() override {for (const auto& observer : observers) {observer->update(state);}}void setState(int state) {this->state = state;notify();}
};int main() {auto subject = std::make_shared<ConcreteSubject>();auto observer1 = std::make_shared<ConcreteObserver>("Observer 1");auto observer2 = std::make_shared<ConcreteObserver>("Observer 2");subject->attach(observer1);subject->attach(observer2);subject->setState(1);subject->setState(2);subject->detach(observer1);subject->setState(3);return 0;
}

3. 命令模式（Command Pattern）

命令模式将请求封装成对象，以便使用不同的请求、队列或者日志来参数化其他对象。命令模式也支持可撤销的操作。

示例代码：

#include <iostream>
#include <vector>
#include <memory>// 命令接口
class Command {
public:virtual void execute() const = 0;
};// 具体命令A
class ConcreteCommandA : public Command {
public:void execute() const override {std::cout << "Executing Command A" << std::endl;}
};// 具体命令B
class ConcreteCommandB : public Command {
public:void execute() const override {std::cout << "Executing Command B" << std::endl;}
};// 调用者
class Invoker {
private:std::vector<std::unique_ptr<Command>> commands;
public:void setCommand(std::unique_ptr<Command> command) {commands.push_back(std::move(command));}void executeCommands() const {for (const auto& command : commands) {command->execute();}}
};int main() {Invoker invoker;invoker.setCommand(std::make_unique<ConcreteCommandA>());invoker.setCommand(std::make_unique<ConcreteCommandB>());invoker.executeCommands();return 0;
}

4. 职责链模式（Chain of Responsibility Pattern）

职责链模式为请求创建了一个接收对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。通过这种模式，多个对象都有机会处理这个请求。

示例代码：

#include <iostream>
#include <memory>// 处理者接口
class Handler {
public:virtual void setNext(std::shared_ptr<Handler> nextHandler) = 0;virtual void handleRequest(int request) = 0;
};// 具体处理者A
class ConcreteHandlerA : public Handler {
private:std::shared_ptr<Handler> next;
public:void setNext(std::shared_ptr<Handler> nextHandler) override {next = nextHandler;}void handleRequest(int request) override {if (request < 10) {std::cout << "ConcreteHandlerA handled request " << request << std::endl;} else if (next) {next->handleRequest(request);}}
};// 具体处理者B
class ConcreteHandlerB : public Handler {
private:std::shared_ptr<Handler> next;
public:void setNext(std::shared_ptr<Handler> nextHandler) override {next = nextHandler;}void handleRequest(int request) override {if (request >= 10 && request < 20) {std::cout << "ConcreteHandlerB handled request " << request << std::endl;} else if (next) {next->handleRequest(request);}}
};int main() {auto handlerA = std::make_shared<ConcreteHandlerA>();auto handlerB = std::make_shared<ConcreteHandlerB>();handlerA->setNext(handlerB);handlerA->handleRequest(5);handlerA->handleRequest(15);return 0;
}

5. 状态模式（State Pattern）

状态模式允许对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。

示例代码：

#include <iostream>
#include <memory>// 状态接口
class State {
public:virtual void handle() = 0;
};// 具体状态A
class ConcreteStateA : public State {
public:void handle() override {std::cout << "Handling state A" << std::endl;}
};// 具体状态B
class ConcreteStateB : public State {
public:void handle() override {std::cout << "Handling state B" << std::endl;}
};// 上下文类
class Context {
private:std::shared_ptr<State> state;
public:Context(std::shared_ptr<State> state) : state(state) {}void setState(std::shared_ptr<State> newState) {state = newState;}void request() {state->handle();}
};int main() {auto stateA = std::make_shared<ConcreteStateA>();auto stateB = std::make_shared<ConcreteStateB>();Context context(stateA);context.request();context.setState(stateB);context.request();return 0;
}

以上示例展示了行为型设计模式的基本概念和如何使用 C++ 实现这些模式。通过这些模式，可以更好地组织代码，实现更灵活和可维护的系统。

从范围来分

设计模式还可以根据范围分为两类：

  1. 类模式（Class Patterns）：

    • 处理类与子类之间的静态关系，主要通过继承来完成。它们在编译时确定，通常是针对类的结构和行为进行定义和操作。

  2. 对象模式（Object Patterns）：

    • 处理对象间的动态关系，主要通过对象的组合和委托来完成。它们在运行时确定，通常是通过定义对象间的通信和协作来实现功能。

类模式（Class Patterns）

  1. 模板方法模式（Template Method）：

    • 定义一个操作中的算法骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变算法的结构即可重新定义算法的某些步骤。
    class AbstractClass {
public:void templateMethod() {primitiveOperation1();primitiveOperation2();}virtual void primitiveOperation1() = 0;virtual void primitiveOperation2() = 0;
};class ConcreteClass : public AbstractClass {
public:void primitiveOperation1() override {// Implementation of primitive operation 1}void primitiveOperation2() override {// Implementation of primitive operation 2}
};

  2. 工厂方法模式（Factory Method）：

    • 定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。
    class Product {
public:virtual void use() = 0;
};class ConcreteProduct : public Product {
public:void use() override {// Implementation}
};class Creator {
public:virtual Product* factoryMethod() = 0;Product* create() {return factoryMethod();}
};class ConcreteCreator : public Creator {
public:Product* factoryMethod() override {return new ConcreteProduct();}
};

对象模式（Object Patterns）

  1. 观察者模式（Observer）：

    • 定义对象间的一对多依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并被自动更新。
    class Observer {
public:virtual void update() = 0;
};class ConcreteObserver : public Observer {
public:void update() override {// Implementation of update}
};class Subject {
private:std::vector<Observer*> observers;public:void attach(Observer* observer) {observers.push_back(observer);}void detach(Observer* observer) {observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end());}void notify() {for (Observer* observer : observers) {observer->update();}}
};

  2. 策略模式（Strategy）：

    • 定义一系列算法，把它们一个个封装起来，并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。
    class Strategy {
public:virtual void algorithmInterface() = 0;
};class ConcreteStrategyA : public Strategy {
public:void algorithmInterface() override {// Implementation of algorithm A}
};class ConcreteStrategyB : public Strategy {
public:void algorithmInterface() override {// Implementation of algorithm B}
};class Context {
private:Strategy* strategy;public:Context(Strategy* s) : strategy(s) {}void setStrategy(Strategy* s) {strategy = s;}void contextInterface() {strategy->algorithmInterface();}
};

类模式和对象模式的区别

  • 类模式：

    • 通过继承关系定义类的静态结构和行为。
    • 继承关系在编译时确定。
    • 类模式通常用来描述类与类之间的关系，主要通过类的继承、模板方法等实现。

  • 对象模式：

    • 通过组合或委托定义对象间的动态关系。
    • 对象间的关系在运行时确定。
    • 对象模式通常用来描述对象之间的协作，主要通过对象的组合、策略、观察者等实现。

通过合理使用类模式和对象模式，可以在设计中实现灵活性和可扩展性，解决复杂的软件设计问题。

从封装变化角度对模式分类

从封装变化的角度来看，设计模式可以分为以下几类：

  1. 组件协作：

    • 封装了对象之间的交互和协作方式。
    • 例子：观察者模式（Observer Pattern）、中介者模式（Mediator Pattern）。

  2. 单一职责：

    • 封装了一个类或对象应当只负责一项职责的原则。
    • 例子：单一职责原则（Single Responsibility Principle），但这更像是一种设计原则而非具体模式。

  3. 对象创建：

    • 封装对象实例化的过程，避免直接使用 new 操作符。
    • 例子：工厂方法模式（Factory Method Pattern）、抽象工厂模式（Abstract Factory Pattern）、生成器模式（Builder Pattern）、原型模式（Prototype Pattern）、单例模式（Singleton Pattern）。

  4. 对象性能：

    • 封装对象性能优化的方法，例如对象的复用、内存管理等。
    • 例子：享元模式（Flyweight Pattern）。

  5. 接口隔离：

    • 封装接口设计，使得接口尽量小而专注于单一职责。
    • 例子：接口隔离原则（Interface Segregation Principle），类似单一职责，这也是一种设计原则。

  6. 状态变化：

    • 封装对象的状态及其变化。
    • 例子：状态模式（State Pattern）、备忘录模式（Memento Pattern）。

  7. 数据结构：

    • 封装数据结构及其操作方法。
    • 例子：组合模式（Composite Pattern）、迭代器模式（Iterator Pattern）。

  8. 行为变化：

    • 封装算法或行为，使其可以在对象间独立变化。
    • 例子：策略模式（Strategy Pattern）、命令模式（Command Pattern）、职责链模式（Chain of Responsibility Pattern）、模板方法模式（Template Method Pattern）。

  9. 领域问题：

    • 封装特定领域的逻辑和问题。
    • 例子：领域驱动设计（Domain-Driven Design），其中包括各种聚合根、实体、值对象等。

以下是每种分类的 C++ 示例：

组件协作

观察者模式：

class Observer {
public:virtual void update() = 0;
};class ConcreteObserver : public Observer {
public:void update() override {// Implementation of update}
};class Subject {
private:std::vector<Observer*> observers;public:void attach(Observer* observer) {observers.push_back(observer);}void detach(Observer* observer) {observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end());}void notify() {for (Observer* observer : observers) {observer->update();}}
};

单一职责

单一职责原则（示例化为类）：

class FileReader {
public:std::string read(const std::string& filePath) {// Read file content}
};class FileWriter {
public:void write(const std::string& filePath, const std::string& content) {// Write content to file}
};

对象创建

工厂方法模式：

class Product {
public:virtual void use() = 0;
};class ConcreteProduct : public Product {
public:void use() override {// Implementation}
};class Creator {
public:virtual Product* factoryMethod() = 0;Product* create() {return factoryMethod();}
};class ConcreteCreator : public Creator {
public:Product* factoryMethod() override {return new ConcreteProduct();}
};

对象性能

享元模式：

class Flyweight {
public:virtual void operation() = 0;
};class ConcreteFlyweight : public Flyweight {
public:void operation() override {// Implementation}
};class FlyweightFactory {
private:std::unordered_map<std::string, Flyweight*> flyweights;public:Flyweight* getFlyweight(const std::string& key) {if (flyweights.find(key) == flyweights.end()) {flyweights[key] = new ConcreteFlyweight();}return flyweights[key];}
};

接口隔离

接口隔离原则（示例化为类）：

class Printer {
public:virtual void print() = 0;
};class Scanner {
public:virtual void scan() = 0;
};class AllInOnePrinter : public Printer, public Scanner {
public:void print() override {// Implementation}void scan() override {// Implementation}
};

状态变化

状态模式：

class State {
public:virtual void handle() = 0;
};class ConcreteStateA : public State {
public:void handle() override {// Implementation of handle A}
};class ConcreteStateB : public State {
public:void handle() override {// Implementation of handle B}
};class Context {
private:State* state;public:Context(State* s) : state(s) {}void setState(State* s) {state = s;}void request() {state->handle();}
};

数据结构

组合模式：

class Component {
public:virtual void operation() = 0;
};class Leaf : public Component {
public:void operation() override {// Implementation of leaf operation}
};class Composite : public Component {
private:std::vector<Component*> children;public:void operation() override {for (Component* child : children) {child->operation();}}void add(Component* component) {children.push_back(component);}void remove(Component* component) {children.erase(std::remove(children.begin(), children.end(), component), children.end());}
};

行为变化

策略模式：

class Strategy {
public:virtual void algorithmInterface() = 0;
};class ConcreteStrategyA : public Strategy {
public:void algorithmInterface() override {// Implementation of algorithm A}
};class ConcreteStrategyB : public Strategy {
public:void algorithmInterface() override {// Implementation of algorithm B}
};class Context {
private:Strategy* strategy;public:Context(Strategy* s) : strategy(s) {}void setStrategy(Strategy* s) {strategy = s;}void contextInterface() {strategy->algorithmInterface();}
};

领域问题

领域驱动设计（示例化为类）：

class ValueObject {
private:int value;public:ValueObject(int v) : value(v) {}int getValue() const {return value;}bool operator==(const ValueObject& other) const {return value == other.value;}
};class Entity {
private:int id;ValueObject valueObject;public:Entity(int i, ValueObject v) : id(i), valueObject(v) {}int getId() const {return id;}ValueObject getValueObject() const {return valueObject;}
};class AggregateRoot : public Entity {
public:using Entity::Entity;void doSomething() {// Implementation}
};

这些示例展示了如何从封装变化的角度，使用C++实现不同的设计模式。

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

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

相关文章

S-Clustr(影子集群)V3 高并发,去中心化,多节点控制

S-Clustr(影子集群)V3 高并发,去中心化,多节点控制

S-Clustr 项目地址:https://github.com/MartinxMax/S-Clustr/releases/tag/S-Clustr-V3.0 Maptnh Не ограничивайте свои действия виртуальным миром. GitHub: Maptnh Jay Steinberg Man kann die Menschen, die man hasst, in d…
阅读更多...
体育赛事翻译欧洲杯足球翻译术语分享

体育赛事翻译欧洲杯足球翻译术语分享

欧洲杯又称欧洲足球锦标赛&#xff0c;是世界上受欢迎和具影响力的国际体育赛事之一&#xff0c;有关足球翻译的术语分享如下&#xff1a; penalty mark (点球)罚球点,midfielder 前卫,center forward 中锋 full back 后卫,bicycle kick / overhead kick 倒钩球,chest-high ba…
阅读更多...
如何用Vue3打造一个交互式数据统计仪表盘

如何用Vue3打造一个交互式数据统计仪表盘

本文由ScriptEcho平台提供技术支持 项目地址&#xff1a;传送门 代码相关技术博客 1. 代码应用场景介绍 本代码示例展示了一个用于展示统计数据的仪表盘界面。它适用于需要可视化跟踪和分析各种指标的应用程序&#xff0c;例如财务管理、健康监测和商业智能。 2. 代码基本…
阅读更多...
机器学习-保存模型并根据模型进行预测 python demo

机器学习-保存模型并根据模型进行预测 python demo

文章目录 前言机器学习-保存模型&#xff0c;根据模型进行预测python demo1. 将我们创建的线性回归模型保存到本地2. 利用我们保存的模型进行房价预测 demo2. 利用我们保存的模型生成对应的预测线性图 demo 前言 如果您觉得有用的话&#xff0c;记得给博主点个赞&#xff0c;评…
阅读更多...
国密SSL证书提升网络安全

国密SSL证书提升网络安全

随着数字化时代的到来&#xff0c;网络安全已经成为全球关注的焦点。在这种背景下&#xff0c;SSL证书作为保护数据传输安全的重要工具&#xff0c;其重要性日益凸显。 数字证书产品有以下几种类别&#xff1a; 单域名SSL证书&#xff1a;为单一网站提供安全保护。 多域名SS…
阅读更多...
恶意软件识别

恶意软件识别

恶意软件识别是保护计算机系统和用户数据安全的重要步骤。以下是关于恶意软件识别的详细分析&#xff1a; 一、恶意软件的定义 恶意软件&#xff08;Malware&#xff09;是指那些被用来对计算机系统造成破坏或者以掩盖本身恶意活动为目的进行隐藏的软件。这些软件会操控、破坏…
阅读更多...
基于HandyControl实现侧边菜单动态加载TabItem的功能

基于HandyControl实现侧边菜单动态加载TabItem的功能

主要功能是点击左侧的 SideMenu 项目&#xff0c;然后在右侧的 TabControl 中创建一个新的 TabItem。这个 TabItem 的内容是一个 TextBlock&#xff0c;显示的是所点击的 SideMenuItem 的 Header 文本。代码还包括了关闭 TabItem 的功能。 以下是具体实现思路&#xff1a; 1.…
阅读更多...
代码随想录算法训练营第四十一天|01背包问题 二维 01背包问题 一维 416. 分割等和子集

代码随想录算法训练营第四十一天|01背包问题 二维 01背包问题 一维 416. 分割等和子集

卡码网 01背包问题 二维 题目链接&#xff1a;01背包问题 二维 踩坑&#xff1a;在考虑当前物品时&#xff0c;应先考虑当前的背包能不能放得下当前物品 思路&#xff1a; 动态数组的含义&#xff1a;dp[i][j]&#xff1a;物品[0, i]在容量为 j 的背包中的最大价值递推公式…
阅读更多...
【PyTorch函数解析】einsum的用法示例

【PyTorch函数解析】einsum的用法示例

一、前言 einsum 是一个非常强大的函数&#xff0c;用于执行张量&#xff08;Tensor&#xff09;运算。它的名称来源于爱因斯坦求和约定&#xff08;Einstein summation convention&#xff09;&#xff0c;在PyTorch中&#xff0c;einsum 可以方便地进行多维数组的操作和计算…
阅读更多...
MySQL中服务器状态变量全解（一）

MySQL中服务器状态变量全解（一）

MySQL 服务器维护了许多状态变量&#xff0c;这些变量提供了关于其操作的信息。您可以使用 SHOW [GLOBAL | SESSION] STATUS 语句来查看这些变量及其值。 GLOBAL 关键字&#xff08;可选&#xff09;用于显示所有连接的聚合值。这些值通常表示自MySQL服务器启动以来的累计统计…
阅读更多...
DWC USB2.0协议学习1--产品概述

DWC USB2.0协议学习1--产品概述

本章开始学习记录DWC_otg控制器&#xff08;新思USB2.0&#xff09;的特点、功能和应用。 新思USB 2.0 IP主要有两个文档需要参考&#xff1a; 《DesignWare Cores USB 2.0 Hi-Speed On-TheGo (OTG) Data book》 《DesignWare Cores USB 2.0 Hi-Speed On-TheGo (OTG) Progra…
阅读更多...
Leetcode85 01矩阵中的最大矩形

Leetcode85 01矩阵中的最大矩形

题目描述 给定一个仅包含 0 和 1 、大小为 rows x cols 的二维二进制矩阵&#xff0c;找出只包含 1 的最大矩形&#xff0c;并返回其面积。 解题思路 动态规划的思想&#xff0c;记录每一个位置向上能到达的最大高度&#xff0c;和向左能到达的最大宽度。 在一个点进行遍历时…
阅读更多...
解决IMX6ULL GPIO扩展板PWM7/8中的pwm0/period后卡死问题

解决IMX6ULL GPIO扩展板PWM7/8中的pwm0/period后卡死问题

前言 本篇文章主要是记录解决百问网论坛上面设置 IMX6ULL GPIO扩展板PWM7/8中的pwm0/period后卡死问题&#xff0c;如下图&#xff1a; 一、查看原理图&#xff0c;找出对应引脚 在这里我们如何确定哪个扩展口中的引脚输出PWM波呢&#xff1f;我们可以通过查看原理图。 查看…
阅读更多...
作业6.20

作业6.20

1.已知网址www.hqyj.com截取出网址的每一个部分(要求&#xff0c;该网址不能存入文件中) 2.将配置桥接网络的过程整理成文档&#xff0c;发csdn 步骤i&#xff1a;在虚拟机设置中启用桥接模式 1. 打开VMware虚拟机软件。 2. 选择您想要配置的虚拟机&#xff0c;点击菜单栏中的“…
阅读更多...
C++ 基础：指针和引用浅谈

C++ 基础：指针和引用浅谈

指针 基本概念 在C中&#xff0c;指针是存储其他变量的内存地址的变量。 我们在程序中声明的每个变量在内存中都有一个关联的位置&#xff0c;我们称之为变量的内存地址。 如果我们的程序中有一个变量 var&#xff0c;那么&var 返回它的内存地址。 int main() {int var…
阅读更多...
北大医院副院长李建平：用AI解决临床心肌缺血预测的难点、卡点和痛点

北大医院副院长李建平：用AI解决临床心肌缺血预测的难点、卡点和痛点

2024年6月14日&#xff0c;第六届北京智源大会在中关村展示中心开幕&#xff0c;海内外的专家学者围绕人工智能关键技术路径和应用场景&#xff0c;展开了精彩演讲与尖峰对话。在「智慧医疗和生物系统&#xff1a;影像、功能与仿真」论坛上&#xff0c;北京大学第一医院副院长、…
阅读更多...
孩子不想上学，父母应如何教育？“强迫教育”会激起孩子反抗心理

孩子不想上学，父母应如何教育？“强迫教育”会激起孩子反抗心理

上周末朋友聚会&#xff0c;都是家有上学娃的年纪&#xff0c;闲聊中&#xff0c;话题自然少不了孩子的上学问题。其中&#xff0c;不少朋友都有抱怨过同一个问题&#xff1a;孩子不想上学&#xff0c;即使人到了学校&#xff0c;心也不在学校。 　　事实上&#xff0c;孩子出现…
阅读更多...
java复习宝典,jdbc与mysql数据库

java复习宝典,jdbc与mysql数据库

一.java 1.面向对象知识 (1)类和对象 类&#xff1a;若干具有相同属性和行为的对象的群体或者抽象&#xff0c;类是创建对象的模板&#xff0c;由属性和行为两部分组成。 类是对象的概括或者抽象&#xff0c;对象是类的实例化。 举例&#xff1a;例如车有很多类型&#xf…
阅读更多...
安卓ROM修改默认开启adb调试

安卓ROM修改默认开启adb调试

要在安卓ROM中修改默认开启ADB调试&#xff0c;你可以遵循以下步骤。请注意&#xff0c;这些步骤可能因设备型号、ROM版本和具体定制方式而有所不同&#xff0c;但基本流程是相似的&#xff1a; 准备工作&#xff1a; 确保你有一台可root的安卓手机&#xff0c;并且已经解锁了…
阅读更多...
计算机系统基础知识（下）

计算机系统基础知识（下）

嵌入式系统以及软件 嵌入式系统是为了特定应用而专门构建且将信息处理过程和物理过程紧密结合为一体的专用计算机系统&#xff0c;这个系统目前以涵盖军事&#xff0c;自动化&#xff0c;医疗&#xff0c;通信&#xff0c;工业控制&#xff0c;交通运输等各个应用领域&#xff…
阅读更多...
最新文章

Copyright @ 2022~2023