【C++】特殊类设计+类型转换+IO流

🌇个人主页：平凡的小苏
📚学习格言：命运给你一个低的起点，是想看你精彩的翻盘，而不是让你自甘堕落，脚下的路虽然难走，但我还能走，比起向阳而生，我更想尝试逆风翻盘。
🛸C++专栏：C++内功修炼基地
> 家人们更新不易，你们的👍点赞👍和⭐关注⭐真的对我真重要，各位路 过的友友麻烦多多点赞关注。 欢迎你们的私信提问，感谢你们的转发！ 关注我，关注我，关注我，你们将会看到更多的优质内容！！

在这里插入图片描述

一、设计一个类，不能拷贝

1、c++98

class CopyBan
{
private:CopyBan(const CopyBan& cb);CopyBan& operator=(const CopyBan& cb);
};
int main()
{return 0;
}

1、将拷贝构造和赋值运算符重载设置为私有；

​ 2、仅仅私有还不够，这并不能防止类内部就行拷贝。还要对拷贝构造和赋值运算符重载只声明却不实现。

2、C++11

class CopyBan
{CopyBan(const CopyBan& cb) = delete;CopyBan& operator=(const CopyBan& cb) = delete;
};

​ C++11直接使用delete禁用拷贝构造和赋值运算符重载。

二、请设计一个类只能在堆上创建对象

1、将构造设置为私有

  1. 将类的构造函数私有，拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。

  2. 提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建

  3. 外部通过CreateObj函数构造一个对象后，外部可以利用这个对象的指针拷贝构造一个栈区的对象，需要禁用拷贝构造。

class HeapOnly
{
public:static HeapOnly* CreateObject(){return new HeapOnly;}
private:HeapOnly() {}// C++98// 1.只声明,不实现。因为实现可能会很麻烦，而你本身不需要// 2.声明成私有HeapOnly(const HeapOnly&);// or// C++11    HeapOnly(const HeapOnly&) = delete;
};

2、将析构设置为私有

在这里插入图片描述

将析构函数设置为私有，栈区对象由于无法析构所以无法创建。堆区对象需要手动调用自己写的清理函数释放。

三、设计一个类只能在栈区设置对象

在这里插入图片描述

1、将构造函数私有；

2、提供一个静态的CreateObj方法用于构造栈区对象；

3、但是无法防止外部构造静态对象。

4、如果想彻底禁止生成静态的对象，需要再禁用拷贝构造。不过这样这个类只能生成临时对象或者引用的对象了，不能修改。

四、请设计一个类，不能被继承

1、C++98方式

// C++98中构造函数私有化，派生类中调不到基类的构造函数。则无法继承
class NonInherit
{public:static NonInherit GetInstance(){return NonInherit();}private:NonInherit(){}
};

2、C++11方式

final关键字，final修饰类，表示该类不能被继承。

class A  final
{// ....
};

五、请设计一个类，只能创建一个对象(单例模式)

一个类只能创建一个对象，即单例模式，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。

1、饿汉模式设计单例对象

class SingLeton
{
public:static SingLeton* getInstance(){return &m_instance;}
private://将构造函数私有SingLeton();//C++98方式防拷贝赋值SingLeton(const SingLeton& sl);SingLeton operator=(const SingLeton& sl);//C++11方式防拷贝赋值SingLeton(const SingLeton& sl) = delete;SingLeton operator=(const SingLeton& sl) = delete;static SingLeton m_instance;// 在程序入口之前就完成单例对象的初始化
};SingLeton SingLeton::m_instance;

饿汉模式：在main函数被加载之前就创建好对象。（全局和静态将在main函数之前被加载）

1、私有构造函数，禁用拷贝构造和赋值运算符重载；

2、在类中声明、外部定义一个静态的对象，用于调用类中私有的构造函数，同时作为单例对象被使用；

3、在类中提供一个获取静态对象的函数GetInstance，为了外部可调用，所以将该函数设置为静态。

饿汉模式的特点：

1、单例对象初始化时，数据太多会导致启动慢；

2、如果多个单例类有初始化的依赖关系，饿汉模式无法控制。例如A和B都是单例类，因为B的启动依赖A，所以需要先初始化A，再初始化B，但是饿汉模式无法控制对象的初始化顺序。

3、饿汉模式创建的对象绝对不会有线程安全问题，因为该模式的对象在main函数之前已经被创建好了，main函数之前线程都没启动呢

2、懒汉模式设计单例对象

如果单例对象构造十分耗时或者占用很多资源，比如加载插件啊， 初始化网络连接啊，读取文件啊等等，而有可能该对象程序运行时不会用到，那么也要在程序一开始就进行初始化，就会导致程序启动时非常的缓慢。 所以这种情况使用懒汉模式（延迟加载）更好。

2.1、懒汉模式的设计以及线程安全问题

#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
#include <string>
#include <ctime>using namespace std;
class SingLeton
{
public:static SingLeton* getInstance(){//双检查加锁if (m_instance == nullptr){_mtx.lock();if (m_instance == nullptr){m_instance = new SingLeton();}_mtx.unlock();}return m_instance;}// 一般全局都要使用单例对象，所以单例对象一般不需要显示释放// 有些特殊场景，想显示释放一下static void DelInstance(){_mtx.lock();if (m_instance){delete m_instance;m_instance = nullptr;}_mtx.unlock();}void Add(const string& str){_mtx.lock();_v.push_back(str);_mtx.unlock();}void Print(){_mtx.lock();for (auto& e : _v){cout << e << endl;}cout << endl;_mtx.unlock();}// 单例对象回收class GC{public:~GC(){DelInstance();}};static GC _gc;
private://将构造函数私有SingLeton(){}//C++11方式防拷贝赋值SingLeton(const SingLeton& sl);SingLeton operator=(const SingLeton& sl);
private:static SingLeton* m_instance;// 在程序入口之前就完成单例对象的初始化static mutex _mtx;//静态锁，全局都能看到vector<string>_v;
};
//静态变量初始化
SingLeton* SingLeton::m_instance = nullptr;
mutex SingLeton::_mtx;
SingLeton::GC SingLeton::_gc;int main()
{srand(time(0));size_t n = 30;thread t1([n]() {for (size_t i = 0; i < n; ++i){SingLeton::getInstance()->Add("t1线程:" + to_string(rand()));}});thread t2([n]() {for (size_t i = 0; i < n; ++i){SingLeton::getInstance()->Add("t2线程:" + to_string(rand()));}});t1.join();t2.join();SingLeton::getInstance()->Print();return 0;
}

懒汉模式的特点：

1、对象在main函数之后才会创建；

2、可以主动控制对象的创建时机。

3、创建对象时存在线程安全问题，如果多个线程同时获取单例对象，会可能new多个对象，最后一个创建的对象指针会覆盖之前创建的对象指针，导致内存泄露。

2.2、懒汉模式需要加锁解决的线程安全问题

在这里插入图片描述

3、单例对象的释放问题

1、一般单例对象不需要考虑释放，资源会在进程结束时自动释放；

2、释放的写法如下：可以手动清理，将一些资源保存：可手动调用DelInstance进行资源的回收，main函数结束时，操作系统也会自动回收单例对象的资源。

在这里插入图片描述

4、比较简洁的懒汉模式

class SingLeton
{
public:static SingLeton* getInstance(){m_instance = new SingLeton();return m_instance;}
private://将构造函数私有SingLeton(){}//C++11方式防拷贝赋值SingLeton(const SingLeton& sl);SingLeton operator=(const SingLeton& sl);
private:static SingLeton* m_instance;// 在程序入口之前就完成单例对象的初始化vector<string>_v;
};
//静态变量初始化
SingLeton* SingLeton::m_instance = nullptr;

1、私有构造函数，禁用拷贝构造和赋值运算符重载；

2、通过getInstance返回静态对象（静态局部变量是在main函数之后才创建初始化）

这种方式构建的单例懒汉模式在C++11发布之前会有线程安全问题，多线程环境下可能会造成静态对象被初始化多次；而C++11规定静态局部变量是线程安全的，可以放心使用。

六、类型转换

1、C语言中的类型转换

C语言中总共有两种形式的类型转换：隐式类型转换和显式类型转换。

  1. 隐式类型转化：编译器在编译阶段自动进行，能转就转，不能转就编译失败

  2. 显式类型转化：需要用户自己处理

void Test ()
{int i = 1;// 隐式类型转换double d = i;printf("%d, %.2f\n" , i, d);int* p = &i;// 显示的强制类型转换int address = (int) p;printf("%x, %d\n" , p, address);
}

缺陷：

转换的可视性比较差，所有的转换形式都是以一种相同形式书写，难以跟踪错误的转换

2、C++中的类型转换

C++尤其认为隐式类型转化有些情况下可能会出问题：比如数据精度丢失。

2.1、static_cast

int main()
{double d = 12.34;int a = static_cast<int>(d);cout << a << endl;return 0;
}

static_cast适用于相似类型的转换。（可以隐式类型转换的都能用static_cast）

2.2、reinterpret_cast

int main()
{double d = 12.34;int a = static_cast<int>(d);cout << a << endl;// 这里使用static_cast会报错，应该使用reinterpret_cast//int *p = static_cast<int*>(a);int* p = reinterpret_cast<int*>(a);return 0;
}

reinterpret_cast适用于不相关类型之间的转换。（不能隐式类型转换，只能强制类型转换的用reinterpret_cast）

2.3、const_cast

int main()
{const int a = 2;int* p = const_cast<int*>(&a);*p = 3;cout << a << endl;cout << *p << endl;return 0;
}

在这里插入图片描述

const_cast用于删除变量的const属性。需要关注内存可见性问题

编译器对const变量会有优化，认为const变量不会被改变，编译器在优化代码时可能会将变量放到寄存器或者其他高速缓存中。可以在a初始化时加上volatile关键字，加了volatile关键字后，对变量的读取和写入操作会从内存中进行，而不是从缓存中进行。

2.4、dynamic_cast

dynamic_cast用于将一个父类对象的指针 / 引用转换为子类对象的指针或引用(动态转换)
向上转型：子类对象指针 / 引用->父类指针 / 引用(不需要转换，赋值兼容规则)
向下转型：父类对象指针 / 引用->子类指针 / 引用(用dynamic_cast转型是安全的)
注意：

1.dynamic_cast只能用于父类含有虚函数的类

2. dynamic_cast会先检查是否能转换成功，能成功则转换，不能则返回0

在这里插入图片描述

3、RTTI

​ RTTI：Run-time Type identifification的简称，即：运行时类型识别。

​ C++通过以下方式来支持RTTI：

1. typeid运算符 
2. dynamic_cast运算符 
3. decltype

七、IO流

1、C语言的输入输出

对输入输出缓冲区的理解：

1.可以屏蔽掉低级I/O的实现，低级I/O的实现依赖操作系统本身内核的实现，所以如果能够屏蔽这部分的差异，可以很容易写出可移植的程序。

2.可以使用这部分的内容实现“行”读取的行为，对于计算机而言是没有“行”这个概念，有了这部分，就可以定义“行”的概念，然后解析缓冲区的内容，返回一个“行”。

2、C++IO流

C++系统实现了一个庞大的类库，其中ios为基类，其他类都是直接或间接派生自ios类

在这里插入图片描述

IO流的特点

1.面向对象

2.更好支持自定义类对象的IO

3、流提取

流提取是一个阻塞操作，以空格或者换行作为一段读取的结束：

在这里插入图片描述

cin>>str是std::string的operator>>所支持的，它的返回值是istream。

在这里插入图片描述

为什么返回值istream可以作为while循环的逻辑判断呢？这是因为ios这个父类重载了operator bool，让其支持了逻辑判断。

在这里插入图片描述

从C++11开始，可以使用explicit关键字来显式声明operator bool()函数，完成istream到bool类型的转变，以避免隐式类型转换带来的问题。（这意味着其内部显式地将istream对象转换为bool类型的值，而不能进行隐式类型转换。可以避免编译器自作主张进行隐式类型转换，例如编译器将一个对象错误地转换为bool类型的值，而导致程序出现错误。）

那么问题来了，为什么void*和bool可以被重载？其实不是他俩能被重载，而是自定义类型可以通过类内重载指定类型完成隐式类型转换。（本质上是隐式类型转换，悄悄的改变类型，上面说了，你重载了类型之后，永远猜不到它会在哪个不该转换的地方发生转换）

在这里插入图片描述

4、C++文件IO流

​ C++根据文件内容的数据格式分为二进制文件和文本文件。采用文件流对象操作文件的一般步骤：

​ 1. 定义一个文件流对象

ifstream(只输入用)

ofstream(只输出用)

fstream(又输出用)

​ 2. 使用文件流对象的成员函数打开一个磁盘文件，使得文件流对象和磁盘文件之间建立联系

​ 3. 使用提取和插入运算符对文件进行读写操作，或使用成员函数进行读写

​ 4. 关闭文件

4.1、二进制读写

struct ServerInfo
{char _address[32];//不要使用stringint _port;
};struct ConfigManager
{ConfigManager(const char* filename):_filename(filename){}void WriteBin(const ServerInfo& info){ofstream ofs(_filename, ofstream::out | ofstream::binary);ofs.write((char*)&info, sizeof(info));}void ReadBin(ServerInfo& info){ifstream ifs(_filename, ifstream::in | ifstream::binary);ifs.read((char*)&info, sizeof(info));}private:string _filename;
};
int main()
{ServerInfo winfo = { "192.0.0.1xxxxxxxxxxxxxxxxxxxxx", 80 };string str;cin >> str;if (str == "二进制写"){ConfigManager cm("test.txt");cm.WriteBin(winfo);}else if (str == "二进制读"){ServerInfo rinfo;ConfigManager cm("test.txt");cm.ReadBin(rinfo);cout << rinfo._address << endl;cout << rinfo._port << endl;}return 0;
}

​ 二进制读写，不要对string对象进行读写操作。

4.2、文本读写（简单写法）

#include <iostream>
#include <fstream>
#include <string>
using namespace std;class Date
{friend ostream& operator << (ostream& out, const Date& d);friend istream& operator >> (istream& in, Date& d);
public:Date(int year = 1, int month = 1, int day = 1):_year(year), _month(month), _day(day){}operator bool(){// 这里是随意写的，假设输入_year为0，则结束if (_year == 0)return false;elsereturn true;}
private:int _year;int _month;int _day;
};istream& operator >> (istream& in, Date& d)
{in >> d._year >> d._month >> d._day;return in;
}
ostream& operator << (ostream& out, const Date& d)
{out << d._year << " " << d._month << " " << d._day;return out;
}
struct ServerInfo
{char _address[32];//不要使用stringint _port;Date _date;
};
struct ConfigManager
{ConfigManager(const char* filename):_filename(filename){}// 文本读写 C++文本读写更简单// 文本读写本质，内存中任何类型都是转成字符串在写// c语言文本读写很不方便，因为要不断转字符串// c++封装了以后就有很大的优势void WriteText(const ServerInfo& info){ofstream ofs(_filename, ofstream::out);ofs << info._address << " ";ofs << info._port << " ";ofs << info._date << endl;}void ReadText(ServerInfo& info){ifstream ifs(_filename, ifstream::in);ifs >> info._address;ifs >> info._port;ifs >> info._date;}
private:string _filename;
};
int main()
{ServerInfo winfo = { "192.0.0.1xxxxxxxxxxxxxxxxxxxxx", 80,{2023,11,5} };string str;cin >> str;if (str == "文本写"){ConfigManager cm("test.txt");cm.WriteText(winfo);}else if (str == "文本读"){ServerInfo rinfo;ConfigManager cm("test.txt");cm.ReadText(rinfo);cout << rinfo._address << endl;cout << rinfo._port << endl;cout << rinfo._date << endl;}return 0;
}

在这里插入图片描述

1、使用ofstream进行写入的时候，每一个变量写完必须给空格或换行，标定每个变量的读取结束，否则读取时会读取出错。

2、自定义类型也可以使用流插入和流提取的写法是因为ofstream和ifstream是ostream的子类，

子类对象可以调用继承于父类的流插入和流提取。（前提是自定义类型重载了流插入和流提取）

5、使用stringstream序列化和反序列化

#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
using namespace std;class Date
{friend ostream& operator << (ostream& out, const Date& d);friend istream& operator >> (istream& in, Date& d);
public:Date(int year = 1, int month = 1, int day = 1):_year(year), _month(month), _day(day){}operator bool(){// 这里是随意写的，假设输入_year为0，则结束if (_year == 0)return false;elsereturn true;}
private:int _year;int _month;int _day;
};istream& operator >> (istream& in, Date& d)
{in >> d._year >> d._month >> d._day;return in;
}
ostream& operator << (ostream& out, const Date& d)
{out << d._year << " " << d._month << " " << d._day;return out;
}
// 序列化和反序列化
struct ChatInfo
{string _name; // 名字int _id;      // idDate _date;   // 时间string _msg;  // 聊天信息
};int main()
{ChatInfo winfo = { "张三", 135246, { 2022, 4, 10 }, "晚上一起看电影吧" };stringstream oss;oss << winfo._name << " ";oss << winfo._id << " ";oss << winfo._date << " ";oss << winfo._msg;string str = oss.str();cout << str << endl;stringstream iss(str);ChatInfo rinfo;iss >> rinfo._name;iss >> rinfo._id;iss >> rinfo._date;iss >> rinfo._msg;cout << "-------------------------------------------------------" << endl;cout << "姓名：" << rinfo._name << "(" << rinfo._id << ") ";cout << rinfo._date << endl;cout << rinfo._name << ":>" << rinfo._msg << endl;cout << "-------------------------------------------------------" << endl;return 0;
}

stringstream兼具ostringstream和istringstream

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

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

相关文章

c语言实现http下载功能，显示进度条和下载速率

c语言实现http下载功能，显示进度条和下载速率

#include <stdio.h>//printf #include <string.h>//字符串处理 #include <sys/socket.h>//套接字 #include <arpa/inet.h>//ip地址处理 #include <fcntl.h>//open系统调用 #include <unistd.h>//write系统调用 #include <netdb.h>//…
阅读更多...
机器学习实战：基于sklearn的工业蒸汽量预测

机器学习实战：基于sklearn的工业蒸汽量预测

文章目录 写在前面工业蒸汽量预测1.基础代码2.模型训练3.模型正则化4.模型交叉验证5.模型超参空间及调参6.学习曲线和验证曲线 写在后面 写在前面 本期内容&#xff1a;基于机器学习的工业蒸汽量预测 实验环境&#xff1a; anaconda python sklearn 注&#xff1a;本专栏内所有…
阅读更多...
K8s学习笔记——认识理解篇

K8s学习笔记——认识理解篇

1. K8s诞生背景 回顾应用的部署&#xff0c;经历了以下几个阶段&#xff1a; 传统部署&#xff1a;物理服务器上运行应用程序。虚拟机部署&#xff1a;物理服务器上安装虚拟机&#xff0c;在虚拟机上运行应用程序。容器部署&#xff1a;物理服务器上安装容器运行时&#xff0…
阅读更多...
YB4554是一款经济高效、完全集成的高端输入电压单电池锂离子电池充电器。

YB4554是一款经济高效、完全集成的高端输入电压单电池锂离子电池充电器。

YB4554 带OVP保护的高输入电压充电器 概述&#xff1a; YB4554是一款经济高效、完全集成的高端输入电压单电池锂离子电池充电器。这个充电器使用锂离子要求的CC/CV充电模式电池充电器可接受高达24V&#xff0c;但当输入电压超过OVP阈值&#xff0c;通常为6.8V&#xff0c;以防…
阅读更多...
antdv使用a-cascader联级选择器实现自定义浮层样式

antdv使用a-cascader联级选择器实现自定义浮层样式

一般的使用组件库想要自定义样式都会使用深度选择器deep去实现 但是有的组件不管是deep还是!important还是写行内样式都改不掉 这里主要讲使用a-cascader联级选择器的浮层改变样式 一&#xff0c;使用组件 <a-cascader:options"regionOptions"change-on-selectv…
阅读更多...
30道高频Vue面试题快问快答

30道高频Vue面试题快问快答

面试中的快问快答 快问快答的情景在面试中非常常见。 在面试过程中&#xff0c;面试官通常会使用快问快答的方式来快速评估面试者的基础知识、思维能力和反应速度。 这种情景下&#xff0c;面试官会提出一系列简短的问题&#xff0c;并期望面试者能够迅速做出回答或提供简洁明…
阅读更多...
云计算实战项目之---学之思在线考试系统

云计算实战项目之---学之思在线考试系统

简介&#xff1a; 学之思开源考试系统是一款 java vue 的前后端分离的考试系统。主要优点是开发、部署简单快捷、界面设计友好、代码结构清晰。支持web端和微信小程序&#xff0c;能覆盖到pc机和手机等设备。 支持多种部署方式&#xff1a;集成部署、前后端分离部署、docker部…
阅读更多...
初识rust

初识rust

调试下rust 的执行流程 参考&#xff1a; 认识 Cargo - Rust语言圣经(Rust Course) 新建一个hello world 程序&#xff1a; fn main() {println!("Hello, world!"); }用IDA 打开exe&#xff0c;并加载符号&#xff1a; 根据字符串找到主程序入口&#xff1a; 双击…
阅读更多...
SpringCloud 微服务全栈体系（十二）

SpringCloud 微服务全栈体系（十二）

第十一章 分布式搜索引擎 elasticsearch 一、初识 elasticsearch 1. 了解 ES 1.1 elasticsearch 的作用 elasticsearch 是一款非常强大的开源搜索引擎&#xff0c;具备非常多强大功能&#xff0c;可以帮助我们从海量数据中快速找到需要的内容 例如&#xff1a; 在 GitHub 搜…
阅读更多...
【安全】Java幂等性校验解决重复点击（6种实现方式）

【安全】Java幂等性校验解决重复点击（6种实现方式）

目录 一、简介1.1 什么是幂等&#xff1f;1.2 为什么需要幂等性&#xff1f;1.3 接口超时&#xff0c;应该如何处理&#xff1f;1.4 幂等性对系统的影响 二、Restful API 接口的幂等性三、实现方式3.1 数据库层面&#xff0c;主键/唯一索引冲突3.2 数据库层面&#xff0c;乐观锁…
阅读更多...
亚马逊云科技产品测评』活动征文｜通过使用Amazon Neptune来预测电影类型初体验

亚马逊云科技产品测评』活动征文｜通过使用Amazon Neptune来预测电影类型初体验

文章目录 福利来袭Amazon Neptune什么是图数据库为什么要使用图数据库什么是Amazon NeptuneNeptune 的特点 快速入门环境搭建notebook 图神经网络快速构建加载数据配置端点Gremlin 查询清理 删除环境S3 存储桶删除 授权声明&#xff1a;本篇文章授权活动官方亚马逊云科技文章转…
阅读更多...
chatgpt升级啦，训练数据时间更新到2023年4月，支持tools（升级functionCall），128k上下文

chatgpt升级啦，训练数据时间更新到2023年4月，支持tools（升级functionCall），128k上下文

&#xff08;2023年11月7日&#xff09; gpt-4-1106-preview https://platform.openai.com/docs/models/gpt-4-and-gpt-4-turbo 训练数据日期升级到2023年四月 上线文增加到128k 调用一次chatgpt接口&#xff0c;可以得到多次函数调用 import OpenAI from "openai"…
阅读更多...
水利部加快推进小型水库除险加固，大坝安全监测是重点

水利部加快推进小型水库除险加固，大坝安全监测是重点

国务院常务会议明确到2025年前&#xff0c;完成新出现病险水库的除险加固&#xff0c;配套完善重点小型水库雨水情和安全监测设施&#xff0c;实现水库安全鉴定和除险加固常态化。 为加快推进小型水库除险加固前期工作&#xff0c;水利部协调财政部提前下达了2023年度中央补助…
阅读更多...
网络流量分类概述

网络流量分类概述

1. 什么是网络流量&#xff1f; 一条网络流量是指在一段特定的时间间隔之内&#xff0c;通过网络中某一个观测点的所有具有相同五元组(源IP地址、目的IP地址、传输层协议、源端口和目的端口)的分组的集合。 比如(10.134.113.77&#xff0c;47.98.43.47&#xff0c;TLSv1.2&…
阅读更多...
YOLOv8-Pose推理详解及部署实现

YOLOv8-Pose推理详解及部署实现

目录 前言一、YOLOv8-Pose推理(Python)1. YOLOv8-Pose预测2. YOLOv8-Pose预处理3. YOLOv8-Pose后处理4. YOLOv8-Pose推理 二、YOLOv8-Pose推理(C)1. ONNX导出2. YOLOv8-Pose预处理3. YOLOv8-Pose后处理4. YOLOv8-Pose推理 三、YOLOv8-Pose部署1. 源码下载2. 环境配置2.1 配置CM…
阅读更多...
web前端js基础------制作滚动图片

web前端js基础------制作滚动图片

1&#xff0c;要求 通过定时器使其出现滚动的效果 可以通过按键控制图片滚动的方向&#xff08;设置两个按钮绑定点击事件&#xff09; 当鼠标悬停时图片停止&#xff0c;鼠标离开时图片继续向前滚动&#xff08;可以设置鼠标的悬停和离开事件&#xff09; 参考如下 conten…
阅读更多...
揭开堆叠式自动编码器的强大功能

揭开堆叠式自动编码器的强大功能

一、介绍 在不断发展的人工智能和机器学习领域&#xff0c;深度学习技术因其处理复杂和高维数据的能力而广受欢迎。在各种深度学习模型中&#xff0c;堆叠式自动编码器是一种多功能且功能强大的工具&#xff0c;可用于特征学习、降维和数据表示。本文探讨了堆叠式自动编码器在深…
阅读更多...
【论文阅读】Generating Radiology Reports via Memory-driven Transformer (EMNLP 2020)

【论文阅读】Generating Radiology Reports via Memory-driven Transformer (EMNLP 2020)

资料链接 论文原文&#xff1a;https://arxiv.org/pdf/2010.16056v2.pdf 代码链接&#xff08;含数据集&#xff09;&#xff1a;https://github.com/cuhksz-nlp/R2Gen/ 背景与动机 这篇文章的标题是“Generating Radiology Reports via Memory-driven Transformer”&#xf…
阅读更多...
【JAVA】：万字长篇带你了解JAVA并发编程-死锁优化【六】

【JAVA】：万字长篇带你了解JAVA并发编程-死锁优化【六】

目录 【JAVA】&#xff1a;万字长篇带你了解JAVA并发编程-并发编程的优化【六】并发编程的优化避免死锁死锁产生的条件避免死锁的方式死锁例程代码使用JpsJstack查看进程死锁问题 避免资源竞争 个人主页: 【⭐️个人主页】 需要您的【&#x1f496; 点赞关注】支持 &#x1f4a…
阅读更多...
C#，数值计算——偏微分方程，谱方法的微分矩阵的计算方法与源程序

C#，数值计算——偏微分方程，谱方法的微分矩阵的计算方法与源程序

1 文本格式 using System; namespace Legalsoft.Truffer { /// <summary> /// 谱方法的微分矩阵 /// Differentiation matrix for spectral methods /// </summary> public class Weights { public Weights() { …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023