设计模式（单例模式、工厂模式及适配器模式、装饰器模式）

目录

0 、设计模式简介

一、单例模式

二、工厂模式

三、适配器模式

四、装饰器模式 

0 、设计模式简介

设计模式可以分为以下三种: 

  1. 创建型模式：用来描述 “如何创建对象”，它的主要特点是 “将对象的创建和使用分离”。包括单例、原型、工厂方法、抽象工厂和建造者 5 种模式。
  2. 结构型模式：用来描述如何将类或对象按照某种布局组成更大的结构。包括代理、适配器、桥接、装饰、外观、享元和组合 7 种模式。
  3. 行为型模式：用来识别对象之间的常用交流模式以及如何分配职责。包括模板方法、策略、命令、职责链、状态、观察者、中介者、迭代器、访问者、备忘录和解释器 11 种模式。

下面将介绍单例模式、工厂模式、适配器模式、组合模式。 

一、单例模式

单例模式的实现需要三个必要的条件：

  1. 单例类的构造函数必须是私有的，这样才能将类的创建权控制在类的内部，从而使得类的外部不能创建类的实例。
  2. 单例类通过一个私有的静态变量来存储其唯一实例。
  3. 单例类通过提供一个公开的静态方法，使得外部使用者可以访问类的唯一实例。

注意：
因为单例类的构造函数是私有的，所以单例类不能被继承。

另外，实现单例类时，还需要考虑三个问题：

  • 创建单例对象时，是否线程安全。
  • 单例对象的创建，是否延时加载。
  • 获取单例对象时，是否需要加锁（锁会导致低性能）。

单例模式分为两种：饿汉方式和懒汉方式

饿汉方式：在类加载的时候就实例化对象，懒汉方式：只有在使用的时候才初始化对象。

饿汉式单例优缺点：

  • 优点：
    • 单例对象的创建是线程安全的；
    • 获取单例对象时不需要加锁。
    • 即不用考虑线程安全问题，不需要加锁，执行效率较高。
  • 缺点：
    • 单例对象的创建，不是延时加载。
    • 类加载的时候就初始化，不管后期用不用都占着空间，浪费了内存

懒汉式单例优缺点：

  • 优点：
    • 对象的创建是线程安全的。
    • 支持延时加载。
  • 缺点：获取对象的操作被加上了锁，影响了并发度。
    • 如果单例对象需要频繁使用，那这个缺点就是无法接受的。
    • 如果单例对象不需要频繁使用，那这个缺点也无伤大雅。

使用场景： 

  • 饿汉式单例模式在类加载时就创建实例，适用于单例对象的创建频繁的场景，以及对于性能要求较高的场景。
  • 懒汉式单例模式在第一次被使用时创建实例，适用于单例对象的创建不是很频繁的场景。

饿汉方式代码：

class singleton{protected:singleton(){}private:static singleton* p;public:static singleton* initance();};singleton* singleton::p = new singleton;singleton* singleton::initance(){return p;}

懒汉方式代码：

class singleton
{
protected:singleton(){pthread_mutex_init(&mutex);}
private:static singleton* p;
public:static pthread_mutex_t mutex;static singleton* initance();
};pthread_mutex_t singleton::mutex;
singleton* singleton::p = NULL;
singleton* singleton::initance()
{if (p == NULL){pthread_mutex_lock(&mutex);if (p == NULL)p = new singleton();pthread_mutex_unlock(&mutex);}return p;
}

二、工厂模式

工厂模式分为简单工厂模式、工厂方法模式、抽象工厂模式。

简单工厂模式：提供一个工厂类，在这个工厂类中生产A、B、C类产品。

工厂方法模式：提供n个工厂类，都继承自同一个总工厂类，然后分别生产各自的产品。

抽象工厂模式：提供n个工厂类，都继承自同一个总工厂类，然后分别生产各自的产品，产品可以包含多种。也就是对于每一个工厂，有多条生产线。

1.简单工厂模式：

NiKeShoes、AdidasShoes、LiNingShoes为具体鞋子的类，分别是耐克、阿迪达斯和李宁鞋牌的鞋，它们都继承于Shoes抽象类。 

// 鞋子抽象类
class Shoes
{
public:virtual ~Shoes() {}virtual void Show() = 0;
};// 耐克鞋子
class NiKeShoes : public Shoes
{
public:void Show(){std::cout << "我是耐克球鞋，我的广告语：Just do it" << std::endl;}
};// 阿迪达斯鞋子
class AdidasShoes : public Shoes
{
public:void Show(){std::cout << "我是阿迪达斯球鞋，我的广告语:Impossible is nothing" << std::endl;}
};// 李宁鞋子
class LiNingShoes : public Shoes
{
public:void Show(){std::cout << "我是李宁球鞋，我的广告语：Everything is possible" << std::endl;}
};

ShoesFactory为工厂类，类里实现根据鞋子类型创建对应鞋子产品对象的CreateShoes(SHOES_TYPE type)函数。 

enum SHOES_TYPE
{NIKE,LINING,ADIDAS
};// 总鞋厂
class ShoesFactory
{
public:// 根据鞋子类型创建对应的鞋子对象Shoes *CreateShoes(SHOES_TYPE type){switch (type){case NIKE:return new NiKeShoes();break;case LINING:return new LiNingShoes();break;case ADIDAS:return new AdidasShoes();break;default:return NULL;break;}}
};

main函数，先是构造了工厂对象，后创建指定类型的具体鞋子产品对象，创建了具体鞋子产品的对象便可直接打印广告。因为采用的是`new`的方式创建了对象，用完了要通过`delete` 释放资源资源。

int main()
{// 构造工厂对象ShoesFactory shoesFactory;// 从鞋工厂对象创建阿迪达斯鞋对象Shoes *pNikeShoes = shoesFactory.CreateShoes(NIKE);if (pNikeShoes != NULL){// 耐克球鞋广告喊起pNikeShoes->Show();// 释放资源delete pNikeShoes;pNikeShoes = NULL;}// 从鞋工厂对象创建阿迪达斯鞋对象Shoes *pLiNingShoes = shoesFactory.CreateShoes(LINING);if (pLiNingShoes != NULL){// 李宁球鞋广告喊起pLiNingShoes->Show();// 释放资源delete pLiNingShoes;pLiNingShoes = NULL;}// 从鞋工厂对象创建阿迪达斯鞋对象Shoes *pAdidasShoes = shoesFactory.CreateShoes(ADIDAS);if (pAdidasShoes != NULL){// 阿迪达斯球鞋广告喊起pAdidasShoes->Show();// 释放资源delete pAdidasShoes;pAdidasShoes = NULL;}return 0;
}

输出结果：

2.工厂方法模式： （有的地方直接是抽象工厂模式，即对工厂也进行了抽象）

ShoesFactory抽象工厂类，提供了创建具体鞋子产品的纯虚函数。

NiKeProducer、AdidasProducer、LiNingProducer具体工厂类，继承持续工厂类，实现对应具体鞋子产品对象的创建。

// 总鞋厂
class ShoesFactory
{
public:virtual Shoes *CreateShoes() = 0;virtual ~ShoesFactory() {}
};// 耐克生产者/生产链
class NiKeProducer : public ShoesFactory
{
public:Shoes *CreateShoes(){return new NiKeShoes();}
};// 阿迪达斯生产者/生产链
class AdidasProducer : public ShoesFactory
{
public:Shoes *CreateShoes(){return new AdidasShoes();}
};// 李宁生产者/生产链
class LiNingProducer : public ShoesFactory
{
public:Shoes *CreateShoes(){return new LiNingShoes();}
};

main函数针对每种类型的鞋子，构造了每种类型的生产线，再由每个生产线生产出对应的鞋子。需注意的是具体工厂对象和具体产品对象，用完了需要通过delete释放资源。 

int main()
{// ================ 生产耐克流程 ==================== //// 鞋厂开设耐克生产线ShoesFactory *niKeProducer = new NiKeProducer();// 耐克生产线产出球鞋Shoes *nikeShoes = niKeProducer->CreateShoes();// 耐克球鞋广告喊起nikeShoes->Show();// 释放资源delete nikeShoes;delete niKeProducer;// ================ 生产阿迪达斯流程 ==================== //// 鞋厂开设阿迪达斯生产者ShoesFactory *adidasProducer = new AdidasProducer();// 阿迪达斯生产线产出球鞋Shoes *adidasShoes = adidasProducer->CreateShoes();// 阿迪达斯球鞋广喊起adidasShoes->Show();// 释放资源delete adidasShoes;delete adidasProducer;return 0;
}

 输出结果：

3.抽象工厂模式： 

鞋厂为了扩大了业务，不仅只生产鞋子，把运动品牌的衣服也一起生产了。

Clothe和Shoes，分别为衣服和鞋子的抽象产品类。

NiKeClothe和NiKeShoes，分别是耐克衣服和耐克衣服的具体产品类。

// 基类 衣服
class Clothe
{
public:virtual void Show() = 0;virtual ~Clothe() {}
};// 耐克衣服
class NiKeClothe : public Clothe
{
public:void Show(){std::cout << "我是耐克衣服，时尚我最在行！" << std::endl;}
};// 基类 鞋子
class Shoes
{
public:virtual void Show() = 0;virtual ~Shoes() {}
};// 耐克鞋子
class NiKeShoes : public Shoes
{
public:void Show(){std::cout << "我是耐克球鞋，让你酷起来！" << std::endl;}
};

Factory为抽象工厂，提供了创建鞋子CreateShoes()和衣服产品CreateClothe()对象的接口。

NiKeProducer为具体工厂，实现了创建耐克鞋子和耐克衣服的方式。

// 总厂
class Factory
{
public:virtual Shoes *CreateShoes() = 0;virtual Clothe *CreateClothe() = 0;virtual ~Factory() {}
};// 耐克生产者/生产链
class NiKeProducer : public Factory
{
public:Shoes *CreateShoes(){return new NiKeShoes();}Clothe *CreateClothe(){return new NiKeClothe();}
};

main函数，构造耐克工厂对象，通过耐克工厂对象再创建耐克产品族的衣服和鞋子对象。同样，对象不再使用时，需要手动释放资源。 

int main()
{// ================ 生产耐克流程 ==================== //// 鞋厂开设耐克生产线Factory *niKeProducer = new NiKeProducer();// 耐克生产线产出球鞋Shoes *nikeShoes = niKeProducer->CreateShoes();// 耐克生产线产出衣服Clothe *nikeClothe = niKeProducer->CreateClothe();// 耐克球鞋广告喊起nikeShoes->Show();// 耐克衣服广告喊起nikeClothe->Show();// 释放资源delete nikeShoes;delete nikeClothe;delete niKeProducer;return 0;
}

 输出结果：

三、适配器模式

适配器模式的作用是解决两个软件实体间的接口不兼容的问题。将一个接口转换成客户希望的另一个接口，使接口不兼容的那些类可以一起工作。

适配器模式有两种实现方法，类适配器和对象适配器。类适配器以多继承方式实现。对象适配器以组合的方式实现，即适配器类中包含了适配者类对象。（调用了适配者类中的方法，即新的方法）

一共包含三个类：目标类、适配者类、适配器类。目标类中的接口和适配者类中的接口不兼容，可通过引入适配器类，在适配器类中，保留了原目标类的接口名，调用了适配者类接口中的功能，对功能重新进行了封装，然后通过目标类指针指向适配器类对象或者目标类引用引用适配器类对象就可调用新的功能，完成对该接口的功能完善。
 

应用场景：通过适配器完成USB与TypeC的对接。原先接口功能是USB接口，新的接口是TypeC接口，需要完成适配，即可以把USB接口当成TypeC接口来使用。（相当于给中间连了转换器）

类适配器代码：

/* Connect Usb port */
class CUsbDisk
{
public:virtual ~CUsbDisk() {}virtual void ConnectDevice(){cout << "Connect usb port." << endl;}
};/* Connect Type-C port */
class CTypeCInterface
{
public:virtual ~CTypeCInterface() {}void ConnectDevice(){cout << "Connect Type-C port." << endl;}
};/* Not only connect Usb port, but also connect Type-C port */
class CAdapter : public CUsbDisk, public CTypeCInterface
{
public:void ConnectDevice(){//调用了适配者类中的方法，即完善了功能，用旧的名字调用了新的功能。CTypeCInterface::ConnectDevice();}
};int main(int argc, char *argv[])
{//通过目标类指针指向适配器类对象，调用了新的方法（原先的接口及新的功能）CUsbDisk *theDisk = new CAdapter();theDisk->ConnectDevice();delete theDisk;return 0;
}

输出结果：

对象适配器模式：

/* Connect Usb port */
class CUsbDisk
{
public:virtual ~CUsbDisk() {}virtual void ConnectDevice(){cout << "Connect usb port." << endl;}
};/* Connect Type-C port */
class CTypeCInterface
{
public:virtual ~CTypeCInterface() {}void ConnectDevice(){cout << "Connect Type-C port." << endl;}
};/* Usb device connect phone */
class CAdapter : public CUsbDisk
{
public:CAdapter(){mpAdaptee = new CTypeCInterface();}~CAdapter(){if (NULL != mpAdaptee) {delete mpAdaptee;}}void ConnectDevice(){if (NULL != mpAdaptee) {mpAdaptee->ConnectDevice();} else {cout << "Adapter abnormal. Connect fail!" << endl;}}private://包含了适配者类对象，通过该对象调用了新的方法，重新封装了旧接口。CTypeCInterface *mpAdaptee;
};int main(int argc, char *argv[])
{CUsbDisk *theDisk = new CAdapter();theDisk->ConnectDevice();delete theDisk;return 0;
}

输出结果：

 或：

/*** The Target defines the domain-specific interface used by the client code.*/
class Target {public:virtual ~Target() = default;virtual std::string Request() const {return "Target: The default target's behavior.";}
};/*** The Adaptee contains some useful behavior, but its interface is incompatible* with the existing client code. The Adaptee needs some adaptation before the* client code can use it.*/
class Adaptee {public:std::string SpecificRequest() const {return ".eetpadA eht fo roivaheb laicepS";}
};/*** The Adapter makes the Adaptee's interface compatible with the Target's* interface using multiple inheritance.*/
class Adapter : public Target, public Adaptee {public:Adapter() {}std::string Request() const override {std::string to_reverse = SpecificRequest();std::reverse(to_reverse.begin(), to_reverse.end());return "Adapter: (TRANSLATED) " + to_reverse;}
};/*** The client code supports all classes that follow the Target interface.*/
void ClientCode(const Target *target) {std::cout << target->Request();
}int main() {std::cout << "Client: I can work just fine with the Target objects:\n";Target *target = new Target;ClientCode(target);std::cout << "\n\n";Adaptee *adaptee = new Adaptee;std::cout << "Client: The Adaptee class has a weird interface. See, I don't understand it:\n";std::cout << "Adaptee: " << adaptee->SpecificRequest();std::cout << "\n\n";std::cout << "Client: But I can work with it via the Adapter:\n";Adapter *adapter = new Adapter;ClientCode(adapter);std::cout << "\n";delete target;delete adaptee;delete adapter;return 0;
}

 结果如下：

Client: I can work just fine with the Target objects:
Target: The default target's behavior.Client: The Adaptee class has a weird interface. See, I don't understand it:
Adaptee: .eetpadA eht fo roivaheb laicepSClient: But I can work with it via the Adapter:
Adapter: (TRANSLATED) Special behavior of the Adaptee.s

四、装饰器模式 

装饰器模式是比较常用的一种设计模式，Python中就内置了对于装饰器的支持。

具体来说，装饰器模式是用来给对象增加某些特性或者对被装饰对象进行某些修改。

如上图所示，需要被装饰的对象在最上方，它自身可以有自己的实例，一般通过抽象类来实现(Java中也可以通过接口实现)。

右侧中间是一个装饰器类或者接口，其实内容与原对象基本一致，不过我们自定义的装饰器一般会继承这个装饰器基类。

最下层就是具体的装饰器了，可以看到，具体装饰器类中需要包含被装饰对象成员（也就是说，装饰器需要和被装饰对象有同样的子类），然后增加一些额外的操作。

下面的代码是一个买煎饼的例子，如我们生活中所见，可以选基础煎饼（鸡蛋煎饼，肉煎饼等），然后再额外加别的东西。

 代码如下：

#include<iostream>
#include<string>
using namespace std;class Pancake//基类
{
public:string description = "Basic Pancake";virtual string getDescription(){ return description; }virtual double cost() = 0;
};class CondimentDecorator :public Pancake//装饰器基类
{
public:string getDescrition();
};class MeatPancake :public Pancake//肉煎饼
{
public:MeatPancake(){ description = "MeatPancake"; }double cost(){ return 6; }
};
class EggPancake :public Pancake//鸡蛋煎饼
{
public:EggPancake(){ description = "EggPancake"; }double cost(){ return 5; }
};class Egg :public CondimentDecorator//额外加鸡蛋
{
public:Pancake* base;string getDescription(){ return base->getDescription() + ", Egg"; }Egg(Pancake* d){ base = d; }double cost(){ return base->cost() + 1.5; }
};
class Potato :public CondimentDecorator//额外加土豆
{
public:Pancake* base;string getDescription(){ return base->getDescription() + ", Potato"; }Potato(Pancake* d){ base = d; }double cost(){ return base->cost() + 1; }
};
class Bacon :public CondimentDecorator//额外加培根
{
public:Pancake* base;string getDescription(){ return base->getDescription() + ", Bacon"; }Bacon(Pancake* d){ base = d; }double cost(){ return base->cost() + 2; }
};int main()
{Pancake* pan = new EggPancake();pan = &Potato(pan);pan = &Bacon(pan);cout << pan->getDescription() << "  $ : " << pan->cost() << endl;system("pause");return 0;
}

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

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

相关文章

小程序request请求封装

小程序request请求封装

以上为本人的项目目录 1.首先在utils中创建request.js文件封装request请求&#xff0c;此封装带上了token&#xff0c;每次请求都会自带token&#xff0c;需要你从后端获取后利用wx.setStorageSync(token,返回的token),不使用的话就是空。 直接复制即可&#xff0c;需要改一下…
阅读更多...
C++STL---Vector、List所要掌握的基本知识

C++STL---Vector、List所要掌握的基本知识

绪论​ 拼着一切代价&#xff0c;奔你的前程。 ——巴尔扎克&#xff1b;本章主要围绕vector和list的使用&#xff0c;以及容器底层迭代器失效问题&#xff0c;同时会有对原码的分析和模拟实现其底层类函数。​​​​话不多说安全带系好&#xff0c;发车啦&#xff08;建议电脑…
阅读更多...
c#使用ExifLib库提取图像的相机型号、光圈、快门、iso、曝光时间、焦距信息等EXIF信息

c#使用ExifLib库提取图像的相机型号、光圈、快门、iso、曝光时间、焦距信息等EXIF信息

近期公司组织了书画摄影比赛&#xff0c;本人作为摄影爱好者&#xff0c;平时也会拍些照片&#xff0c;这次比赛当然不能错过。为了提高获奖概率&#xff0c;选了19张图像作为参赛作品。但是&#xff0c;摄影作品要提交图像的光圈、曝光时间等参数。一两张还可以通过电脑自带软…
阅读更多...
【uniapp】仿微信支付界面

【uniapp】仿微信支付界面

效果图 完整代码 <template><view class="my-pay-page"><view :style=
阅读更多...
软件测试---边界值分析（功能测试）

软件测试---边界值分析（功能测试）

选取正好等于、刚好大于、刚好小于边界的值作为测试数据 上点: 边界上的点 (正好等于)&#xff1b;必选(不考虑区开闭) 内点: 范围内的点 (区间范围内的数据)&#xff1b;必选(建议选择中间范围) 离点: 距离上点最近的点 (刚好大于、刚好小于)&#xff1b;开内闭外(考虑开…
阅读更多...
Redis(windows+Linux)安装及入门

Redis(windows+Linux)安装及入门

一、概述 Redis是什么&#xff1f; Redis(Remote Dictionary Server)&#xff0c;即远程字典服务 Redis&#xff08;Remote Dictionary Server )&#xff0c;即远程字典服务&#xff0c;是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数…
阅读更多...
Linux shell编程学习笔记16：bash中的关联数组

Linux shell编程学习笔记16：bash中的关联数组

上一节我们探讨了普通的数组&#xff0c;即使用数字下标来索引数组中不同的元素的数组&#xff0c;也可以称之为索引数组。 相比纯粹的数字&#xff0c;字符串不仅能表明含义&#xff0c;也更便于记忆使用&#xff0c;于是就有了关联数组。 一、关联数组概述 bash 从4.0开始支…
阅读更多...
力扣第738题 单调递增的数字 c++ 暴力超时 贪心优化

力扣第738题 单调递增的数字 c++ 暴力超时 贪心优化

题目 738. 单调递增的数字 中等 相关标签 贪心 数学 当且仅当每个相邻位数上的数字 x 和 y 满足 x < y 时&#xff0c;我们称这个整数是单调递增的。 给定一个整数 n &#xff0c;返回 小于或等于 n 的最大数字&#xff0c;且数字呈 单调递增 。 示例 1: 输入: n 1…
阅读更多...
精品基于Python的房地产分析平台-可视化大屏

精品基于Python的房地产分析平台-可视化大屏

《[含文档PPT源码等]精品基于Python的房地产分析平台的设计与实现-爬虫》该项目含有源码、文档、PPT、配套开发软件、软件安装教程、项目发布教程、包运行成功&#xff01; 软件开发环境及开发工具&#xff1a; 开发语言&#xff1a;python 使用框架&#xff1a;Django 前端…
阅读更多...
Java VMTranslator Part I

Java VMTranslator Part I

目录 堆栈运算命令 基本思路 核心代码 Parser Code Writer Main 实验结果&#xff0c;使用SimpleAdd、StackTest进行验证 内存访问命令 基本思路 核心代码 Parser Code Writer Main 实验结果&#xff0c;使用进行验证。对比生成的二进制代码文件。 用Java写一个翻…
阅读更多...
程序员为啥要做副业(02)-中指备用金

程序员为啥要做副业(02)-中指备用金

点击下方“JavaEdge”&#xff0c;选择“设为星标” 第一时间关注技术干货&#xff01; 免责声明~ 任何文章不要过度深思&#xff01; 万事万物都经不起审视&#xff0c;因为世上没有同样的成长环境&#xff0c;也没有同样的认知水平&#xff0c;更「没有适用于所有人的解决方案…
阅读更多...
Linux — vim编辑器的操作

Linux — vim编辑器的操作

目录 1. vim的整体操作2. 命令模式下的常见命令3. 底行模式下的常见命令结语 1. vim的整体操作 我们使用 touch 创建一个文件之后&#xff0c;直接 vim 文件名 就能够进入到vim编辑器中。如果vim 文件名的文件还不存在时&#xff0c;vim会自动创建该文件&#xff0c;但需要保存…
阅读更多...
Java 中的 synchronized 同步锁

Java 中的 synchronized 同步锁

导致线程安全问题的根本原因在于&#xff0c;存在多个线程同时操作一个共享资源&#xff0c;要想解决这个问题&#xff0c;就需要保证对共享资源访问的独占性&#xff0c;因此人们在Java中提供了synchronized关键字&#xff0c;我们称之为同步锁&#xff0c;它可以保证在同一时…
阅读更多...
Spring Cloud之API网关（Gateway）

Spring Cloud之API网关（Gateway）

目录 API网关 好处 解决方案 Gateway 简介 特征 核心概念 Route(路由) Predicate(断言) Filter(过滤器) 工作流程 Route(路由) 路由配置方式 1.yml配置文件路由 2.bean进行配置 3.动态路由 动态路由 Predicate(断言) 特点 常见断言 示例 Filter(过滤器) …
阅读更多...
IOC课程整理-19 Spring Environment 抽象

IOC课程整理-19 Spring Environment 抽象

1. 理解 Spring Environment 抽象 2. Spring Environment 接口使用场景 3. Environment 占位符处理 4. 理解条件配置 Spring Profiles 5. Spring 4 重构 Profile 6. 依赖注入 Environment 7. 依赖查找 Environment 8. 依赖注入 Value 9. Spring 类型转换在 Environment 中的运用…
阅读更多...
ZYNQ连载01-ZYNQ介绍

ZYNQ连载01-ZYNQ介绍

ZYNQ连载01-ZYNQ介绍 1. ZYNQ 参考文档&#xff1a;《ug585-zynq-7000-trm.pdf》 ZYNQ分为PS和PL两大部分&#xff0c;PS即ARM&#xff0c;PL即FPGA&#xff0c;PL作为PS的外设。 2. 方案 ZYNQ7020为双核A9架构&#xff0c;多核处理器常用的运行模式为AMP(非对称多处理)和…
阅读更多...
测试C#调用Vlc.DotNet组件播放视频

测试C#调用Vlc.DotNet组件播放视频

除了Windows Media Player组件&#xff0c;在百度上搜索到还有不少文章介绍采用Vlc.DotNet组件播放视频&#xff0c;关于Vlc.DotNet的详细介绍见参考文献1&#xff0c;本文学习Vlc.DotNet的基本用法。   VS2022中新建基于.net core的winform程序&#xff0c;在Nuget包管理器中…
阅读更多...
[论文精读]How Powerful are Graph Neural Networks?

[论文精读]How Powerful are Graph Neural Networks?

论文原文&#xff1a;[1810.00826] How Powerful are Graph Neural Networks? (arxiv.org) 英文是纯手打的&#xff01;论文原文的summarizing and paraphrasing。可能会出现难以避免的拼写错误和语法错误&#xff0c;若有发现欢迎评论指正&#xff01;文章偏向于笔记&#x…
阅读更多...
脚本木马编写

脚本木马编写

PHP小马编写 小马用waf扫描&#xff0c;没扫描出来有风险。 小马过waf之后用echo $_SERVER[DOCUMENT_ROOT]获得当前运行脚本所在的文档根目录。&#xff0c;然后在上传大马工具。 $_SERVER&#xff0c;参考&#xff1a;PHP $_SERVER详解 小马编写二次加密 现在是可以被安全…
阅读更多...
辅助驾驶功能开发-功能规范篇(22)-4-L2级辅助驾驶方案功能规范

辅助驾驶功能开发-功能规范篇(22)-4-L2级辅助驾驶方案功能规范

1.3.4 LDW系统功能定义 1.3.4.1 状态机 1.3.4.2 功能定义 1.3.4.2.1 信号需求列表 1.3.4.2.2 系统开启关闭 1）初始化 车辆上电后，车道偏离预警系统（LDW）进行初始化，控制器需要在上电后 220ms 内发出第一帧报文，并在 3s 内 完成内部自检，同时上电 3s 内不进行关联系统…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023