【C++】封装unordered_map和unordered_set（用哈希桶实现）

前言：
       前面我们学习了unordered_map和unordered_set容器，比较了他们和map、set的查找效率，我们发现他们的效率比map、set高，进而我们研究他们的底层是由哈希实现。哈希是一种直接映射的方式，所以查找的效率很快。与学习红黑树和map、set的思路一样，我们现在学完了unordered_map和unordered_set，本章将模拟实现底层结构来封装该容器！

    作者建议在阅读本章前，可以先去看一下前面的红黑树封装map和set——红黑树封装map和set

这两篇文章都重在强调泛型编程的思想，上一篇由于是初认识，作者讲解的会更详细一点~

目录

（一）如何复用一个哈希桶

1、结点的定义：

2、两个容器各自的模板参数类型​编辑

3、改造哈希桶

（二）哈希桶的迭代器的模拟实现

1、begin()和end()的模拟实现

2、operator*和operator->及operator!=和operator==的模拟实现 

3、operator ++的模拟实现

（三）迭代器和改造哈希桶的总代码

（四）封装unordered_map和unordered_set

（一）如何复用一个哈希桶

我们学习过知道，unordered_map和unordered_set容器存放的结点并不一样，为了让它得到复用，我们就需要对哈希桶进行改造，将哈希桶改造的更加泛型一点，既符合Key模型，也符合Key_Value模型。

1、结点的定义：

 所以我们这里还是和封装map和set时一样，无论是Key还是Key_Value，都用一个类型T来接收，这里高维度的泛型哈希表中，实现还是用的是Kye_Value模型，K是不能省略的，同样的查找和删除要用，故我们可以引出两个容器各自模板参数类型。

2、两个容器各自的模板参数类型

如何取到想要的数据：

  • 我们给每个容器配一个仿函数
  • 各传不同的仿函数，拿到想要的不同的数据

同时我们再给每个容器配一个哈希函数。

3、改造哈希桶

通过上面1和2，我们可以把各自存放的数据泛化成data：

这样我们哈希桶的模板参数算是完成了

  • 哈希函数我们可以自由选择并传
  • 仿函数在各自容器的封装中实现，用于比较时我们可以取出各自容器想要的数据

我们把上一篇文章封装的哈希桶拿来改造：

//K --> 键值Key，T --> 数据
//unordered_map ->HashTable<K, pair<K, V>, MapKeyOfT> _ht;
//unordered_set ->HashTable<K, K, SetKeyOfT> _ht;
template<class K, class T, class KeyOfT, class HashFunc>
class HashTable
{template<class K, class T, class KeyOfT, class HashFunc>friend class __HTIterator;typedef HashNode<T> Node;
public:typedef __HTIterator<K, T, KeyOfT, HashFunc> iterator;iterator begin(){for (size_t i = 0; i < _tables.size(); i++){Node* cur = _tables[i];if (cur){return iterator(cur, this);}}return end();}iterator end(){return iterator(nullptr, this);}~HashTable(){for (size_t i = 0; i < _tables.size(); i++){Node* cur = _tables[i];while (cur){Node* next = cur->_next;delete cur;cur = next;}_tables[i] = nullptr;}}size_t GetNextPrime(size_t prime){const int PRIMECOUNT = 28;static const size_t primeList[PRIMECOUNT] ={53,         97,         193,       389,       769,1543,       3079,       6151,      12289,     24593,49157,      98317,      196613,    393241,    786433,1572869,    3145739,    6291469,   12582917,  25165843,50331653,   100663319,  201326611, 402653189, 805306457,1610612741, 3221225473, 4294967291};//获取比prime大那一个素数size_t i = 0;for (i = 0; i < PRIMECOUNT; i++){if (primeList[i] > prime)return primeList[i];}return primeList[i];}pair<iterator, bool> Insert(const T& data){HashFunc hf;KeyOfT kot;iterator pos = Find(kot(data));if (pos != end()){return make_pair(pos, false);}//负载因子 == 1 扩容 -- 平均每个桶挂一个结点if (_tables.size() == _n){//size_t newSize = _tables.size() == 0 ? 10 : _tables.size() * 2;size_t newSize = GetNextPrime(_tables.size());if (newSize != _tables.size()){vector<Node*> newTable;newTable.resize(newSize, nullptr);//遍历旧表for (size_t i = 0; i < _tables.size(); i++){Node* cur = _tables[i];//再对每个桶挨个遍历while (cur){Node* next = cur->_next;size_t hashi = hf(kot(cur->_data)) % newSize;//转移到新的表中cur->_next = newTable[hashi];newTable[hashi] = cur;cur = next;}//将原表置空_tables[i] = nullptr;}newTable.swap(_tables);}}size_t hashi = hf(kot(data));hashi %= _tables.size();//头插到对应的桶即可Node* newnode = new Node(data);newnode->_next = _tables[hashi];_tables[hashi] = newnode;//有效数据加一_n++;return make_pair(iterator(newnode, this), true);}iterator Find(const K& key){if (_tables.size() == 0){return iterator(nullptr, this);}KeyOfT kot;HashFunc hf;size_t hashi = hf(key);//size_t hashi = HashFunc()(key);hashi %= _tables.size();Node* cur = _tables[hashi];//找到指定的桶之后，顺着单链表挨个找while (cur){if (kot(cur->_data) == key){return iterator(cur, this);}cur = cur->_next;}//没找到返回空return iterator(nullptr, this);}bool Erase(const K& key){if (_tables.size() == 0){return false;}HashFunc hf;KeyOfT kot;size_t hashi = hf(key);hashi %= _tables.size();//单链表删除结点Node* prev = nullptr;Node* cur = _tables[hashi];while (cur){if (kot(cur->_data) == key){//头删if (prev == nullptr){_tables[hashi] = cur->_next;}else{prev->_next = cur->_next;}delete cur;return true;}prev = cur;cur = cur->_next;}return false;}
private://指针数组vector<Node*> _tables;size_t _n = 0;
};

主要改造的地方就是上述所注意的地方：

  • 比较时需要调用各自的仿函数
  • 调用外部传的哈希函数

还有对扩容的二次思考：

研究表明：除留余数法，最好模一个素数

  • 通过查STL官方库我们也发现，其提供了一个取素数的函数
  • 所以我们也提供了一个，直接拷贝过来
    • 这样我们在扩容时就可以每次给素数个桶
    • 在扩容时加了一条判断语句是为了防止素数值太大，过分扩容容易直接把空间(堆)干崩了

（二）哈希桶的迭代器的模拟实现

1、begin()和end()的模拟实现

  • 以第一个桶中第一个不为空的结点为整个哈希桶的开始结点
  • 以空结点为哈希桶的结束结点

2、operator*和operator->及operator!=和operator==的模拟实现 

这两组和之前实现的一模一样，大家自行理解。

3、operator ++的模拟实现

注：

  • 这里要在哈希桶的类外面访问其私有成员
  • 我们要搞一个友元类
  • 迭代器类是哈希桶类的朋友
  • 这样就可以访问了

 

思路：

  • 判断一个桶中的数据是否遍历完
  • 如果所在的桶没有遍历完，在该桶中返回下一个结点指针
  • 如果所在的桶遍历完了，进入下一个桶
  • 判断下一个桶是否为空
  • 非空返回桶中第一个节点
  • 空的话就遍历一个桶
  • 后置++和之前一眼老套路，不赘述

注意：

unordered_map和unordered_set是不支持反向迭代器的，从底层结构我们也能很好的理解（单链表找不了前驱）所以不支持实现迭代器的operator- -

最后注意一点，我们需要知道哈希桶大小，所以不仅要传结点地址，还要传一个哈希桶，这样才能知道其大小，除此，由于哈希桶改造在后面，所以我们要在前面声明一下：

（三）迭代器和改造哈希桶的总代码

#include<vector>
#include<string>
#include<iostream>
using namespace std;template<class K>
struct DefaultHash
{size_t operator()(const K& key){return (size_t)key;}
};template<>
struct DefaultHash<string>
{size_t operator()(const string& key){//BKDRsize_t hash = 0;for (auto ch : key){hash = hash * 131 + ch;}return hash;}
};namespace Bucket
{template<class T>struct HashNode{T _data;HashNode<T>* _next;HashNode(const T& data):_data(data), _next(nullptr){}};template<class K, class T, class KeyOfT, class HashFunc>class HashTable;//哈希桶的迭代器template<class K, class T, class KeyOfT, class HashFunc>class __HTIterator{typedef HashNode<T> Node;typedef __HTIterator<K, T, KeyOfT, HashFunc> Self;public:Node* _node;__HTIterator() {};//编译器的原则是向上查找（定义必须在前面，否则必须先声明）HashTable<K, T, KeyOfT, HashFunc>* _pht;__HTIterator(Node* node, HashTable<K, T, KeyOfT, HashFunc>* pht):_node(node), _pht(pht){}Self& operator++(){if (_node->_next){_node = _node->_next;}else//当前桶已经走完了，要走下一个桶{KeyOfT kot;HashFunc hf;size_t hashi = hf(kot(_node->_data)) % _pht->_tables.size();hashi++;//找下一个不为空的桶 -- 访问到了哈希表中私有的成员（友元）for (; hashi < _pht->_tables.size(); hashi++){if (_pht->_tables[hashi]){_node = _pht->_tables[hashi];break;}}//没有找到不为空的桶，用nullptr去做end标识if (hashi == _pht->_tables.size()){_node = nullptr;}}return *this;}T& operator*(){return _node->_data;}T* operator->(){return &_node->_data;}bool operator!=(const Self& s) const{return _node != s._node;}bool operator==(const Self& s) const{return _node == s._node;}};//K --> 键值Key，T --> 数据//unordered_map ->HashTable<K, pair<K, V>, MapKeyOfT> _ht;//unordered_set ->HashTable<K, K, SetKeyOfT> _ht;template<class K, class T, class KeyOfT, class HashFunc>class HashTable{template<class K, class T, class KeyOfT, class HashFunc>friend class __HTIterator;typedef HashNode<T> Node;public:typedef __HTIterator<K, T, KeyOfT, HashFunc> iterator;iterator begin(){for (size_t i = 0; i < _tables.size(); i++){Node* cur = _tables[i];if (cur){return iterator(cur, this);}}return end();}iterator end(){return iterator(nullptr, this);}~HashTable(){for (size_t i = 0; i < _tables.size(); i++){Node* cur = _tables[i];while (cur){Node* next = cur->_next;delete cur;cur = next;}_tables[i] = nullptr;}}size_t GetNextPrime(size_t prime){const int PRIMECOUNT = 28;static const size_t primeList[PRIMECOUNT] ={53,         97,         193,       389,       769,1543,       3079,       6151,      12289,     24593,49157,      98317,      196613,    393241,    786433,1572869,    3145739,    6291469,   12582917,  25165843,50331653,   100663319,  201326611, 402653189, 805306457,1610612741, 3221225473, 4294967291};//获取比prime大那一个素数size_t i = 0;for (i = 0; i < PRIMECOUNT; i++){if (primeList[i] > prime)return primeList[i];}return primeList[i];}pair<iterator, bool> Insert(const T& data){HashFunc hf;KeyOfT kot;iterator pos = Find(kot(data));if (pos != end()){return make_pair(pos, false);}//负载因子 == 1 扩容 -- 平均每个桶挂一个结点if (_tables.size() == _n){//size_t newSize = _tables.size() == 0 ? 10 : _tables.size() * 2;size_t newSize = GetNextPrime(_tables.size());if (newSize != _tables.size()){vector<Node*> newTable;newTable.resize(newSize, nullptr);//遍历旧表for (size_t i = 0; i < _tables.size(); i++){Node* cur = _tables[i];//再对每个桶挨个遍历while (cur){Node* next = cur->_next;size_t hashi = hf(kot(cur->_data)) % newSize;//转移到新的表中cur->_next = newTable[hashi];newTable[hashi] = cur;cur = next;}//将原表置空_tables[i] = nullptr;}newTable.swap(_tables);}}size_t hashi = hf(kot(data));hashi %= _tables.size();//头插到对应的桶即可Node* newnode = new Node(data);newnode->_next = _tables[hashi];_tables[hashi] = newnode;//有效数据加一_n++;return make_pair(iterator(newnode, this), true);}iterator Find(const K& key){if (_tables.size() == 0){return iterator(nullptr, this);}KeyOfT kot;HashFunc hf;size_t hashi = hf(key);//size_t hashi = HashFunc()(key);hashi %= _tables.size();Node* cur = _tables[hashi];//找到指定的桶之后，顺着单链表挨个找while (cur){if (kot(cur->_data) == key){return iterator(cur, this);}cur = cur->_next;}//没找到返回空return iterator(nullptr, this);}bool Erase(const K& key){if (_tables.size() == 0){return false;}HashFunc hf;KeyOfT kot;size_t hashi = hf(key);hashi %= _tables.size();//单链表删除结点Node* prev = nullptr;Node* cur = _tables[hashi];while (cur){if (kot(cur->_data) == key){//头删if (prev == nullptr){_tables[hashi] = cur->_next;}else{prev->_next = cur->_next;}delete cur;return true;}prev = cur;cur = cur->_next;}return false;}private://指针数组vector<Node*> _tables;size_t _n = 0;};
}

（四）封装unordered_map和unordered_set

有了上面的哈希桶的改装，我们这里的对map和set的封装就显得很得心应手了。

unordered_map的封装：

#include "HashTable.h"namespace zc
{template<class K, class V, class HashFunc = DefaultHash<K>>class unordered_map{struct MapKeyOfT{const K& operator()(const pair<K, V>& kv){return kv.first;}};public:typedef typename Bucket::HashTable<K, pair<K, V>, MapKeyOfT, HashFunc>::iterator iterator;iterator begin(){return _ht.begin();}iterator end(){return _ht.end();}pair<iterator, bool> insert(const pair<K, V>& kv){return _ht.Insert(kv);}iterator find(const K& key){return _ht.Find(key);}bool erase(const K& key){return _ht.Erase(key);}V& operator[](const K& key){pair<iterator, bool> ret = insert(make_pair(key, V()));return ret.first->second;}private:Bucket::HashTable<K, pair<K, V>, MapKeyOfT, HashFunc> _ht;};void test_map(){unordered_map<string, string> dict;dict.insert(make_pair("sort", "排序"));dict.insert(make_pair("left", "左边"));dict.insert(make_pair("left", "下面"));dict["string"];dict["left"] = "上面";dict["string"] = "字符串";unordered_map<string, string>::iterator it = dict.begin();while (it != dict.end()){cout << it->first << " " << it->second << endl;++it;}cout << endl;for (auto e : dict){cout << e.first << " " << e.second << endl;}}}

这里unordered_map中的operator[ ]我们知道其原理之后，模拟实现就非常方便，直接调用插入函数，控制好参数和返回值即可。

对unordered_set的封装：

#include "HashTable.h"#include "HashTable.h"namespace zc
{template<class K, class HashFunc = DefaultHash<K>>class unordered_set{struct SetKeyOfT{const K& operator()(const K& key){return key;}};public://2.48typedef typename Bucket::HashTable<K, K, SetKeyOfT, HashFunc>::iterator iterator;iterator begin(){return _ht.begin();}iterator end(){return _ht.end();}pair<iterator, bool> insert(const K& key){return _ht.Insert(key);}iterator find(const K& key){return _ht.Find(key);}bool erase(const K& key){return _ht.Erase(key);}private:Bucket::HashTable<K, K, SetKeyOfT, HashFunc> _ht;};struct Date{Date(int year = 1, int month = 1, int day = 1):_year(year), _month(month), _day(day){}bool operator==(const Date& d) const{return _year == d._year&& _month == d._month&& _day == d._day;}int _year;int _month;int _day;};struct DateHash{size_t operator()(const Date& d){//return d._year + d._month + d._day;size_t hash = 0;hash += d._year;hash *= 131;hash += d._month;hash *= 1313;hash += d._day;//cout << hash << endl;return hash;}};void test_set(){unordered_set<int> s;//set<int> s;s.insert(2);s.insert(3);s.insert(1);s.insert(2);s.insert(5);s.insert(12);unordered_set<int>::iterator it = s.begin();//auto it = s.begin();while (it != s.end()){cout << *it << " ";++it;}cout << endl;for (auto e : s){cout << e << " ";}cout << endl;unordered_set<Date, DateHash> sd;sd.insert(Date(2022, 3, 4));sd.insert(Date(2022, 4, 3));}
}

最后大家可以利用代码中给的测试函数进行测试！

感谢你的阅读！

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

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

相关文章

LeetCode——动态规划篇（一）

LeetCode——动态规划篇（一）

刷题顺序及思路来源于代码随想录&#xff0c;网站地址&#xff1a;https://programmercarl.com 目录 509. 斐波那契数 - 力扣&#xff08;LeetCode&#xff09; 70. 爬楼梯 - 力扣&#xff08;LeetCode&#xff09; 746. 使用最小花费爬楼梯 - 力扣&#xff08;LeetCode&a…
阅读更多...
瞄准办公场景，未来智能靠“AI+耳机”后来居上？

瞄准办公场景，未来智能靠“AI+耳机”后来居上？

如何在广阔红海中开拓出蓝海&#xff1f;未来智能或可作为参考案例。 作为TWS耳机玩家&#xff0c;未来智能成立于2021年&#xff0c;日前完成了由天际资本领投的数千万元Pre-A轮融资&#xff0c;这也是该公司成立以来完成的第二轮融资。 从成立时间来看&#xff0c;在广阔的…
阅读更多...
Linux---应用层获取usb设备描述信息通过endpoint地址数据通讯

Linux---应用层获取usb设备描述信息通过endpoint地址数据通讯

文章目录 &#x1f308;应用层获取USB设备信息总体思路&#x1f308;应用层代码实例&#x1f308;实例测试&#x1f308;应用层通过endpoint进行数据读写 &#x1f308;应用层获取USB设备信息总体思路 应用层可以打开USB设备的节点&#xff0c;读取包括USB设备的配置&#xff…
阅读更多...
deepspeed训练报错torch.distributed.elastic.multiprocessing.errors.ChildFailedError

deepspeed训练报错torch.distributed.elastic.multiprocessing.errors.ChildFailedError

测试场景&#xff1a;使用deepspeed框架训练gpt模型 问题&#xff1a; 报错torch.distributed.elastic.multiprocessing.errors.ChildFailedError 具体见截图&#xff1a;
阅读更多...
UMA 2 - Unity Multipurpose Avatar☀️六.Advanced Occlusion高级遮挡功能解决皮肤服饰穿模

UMA 2 - Unity Multipurpose Avatar☀️六.Advanced Occlusion高级遮挡功能解决皮肤服饰穿模

文章目录 🟥 本节功能效果展示🟧 基础项目配置🟨 本节项目配置🟩 配置MeshHideAsset1️⃣ 创建MeshHideAsset2️⃣ 配置SlotDataAsset3️⃣ 配置遮挡信息🟦 将 MeshHideAsset 配置到 Recipe🟥 本节功能效果展示 未遮挡前的穿模问题: 遮挡后效果:
阅读更多...
厂商征集 | 2023年中国RPA市场洞察研究报告正式启动

厂商征集 | 2023年中国RPA市场洞察研究报告正式启动

RPA中国基于在科技行业的资源积累&#xff0c;以及对各领域「技术领导者」、「技术应用者」、「产品服务商」的深度调研&#xff0c;2023年&#xff0c;我们重点推出MI报告 ( Market Insight )、CI Vendor报告&#xff08;Comprehensive Influence Vendor&#xff09;两个系列。…
阅读更多...
【Jmeter】什么是BeanShell？

【Jmeter】什么是BeanShell？

一、什么是BeanShell&#xff1f; BeanShell是用Java写成的,一个小型的、免费的、可以下载的、嵌入式的Java源代码解释器&#xff0c;JMeter性能测试工具也充分接纳了BeanShell解释器&#xff0c;封装成了可配置的BeanShell前置和后置处理器&#xff0c;分别是 BeanShell Pre…
阅读更多...
NoSQL之Redis配置与优化（一）

NoSQL之Redis配置与优化（一）

关系数据库与非关系型数据库 &#xff1a; ●关系型数据库&#xff1a; 关系型数据库是一个结构化的数据库&#xff0c;创建在关系模型&#xff08;二维表格模型&#xff09;基础上&#xff0c;一般面向于记录。 SQL 语句&#xff08;标准数据查询语言&#xff09;就是一种基于…
阅读更多...
FP7122 具有平均模式恒定电流控制的LED驱动器芯片

FP7122 具有平均模式恒定电流控制的LED驱动器芯片

FP7122 具有平均模式恒定电流控制的LED驱动器芯片 一般说明 FP7122是在恒定关闭时间模式下工作的平均电流模式控制LED驱动器IC。FP7122不产生峰值到平均的误差&#xff0c;因此大大提高了LED电流的精度、线路和负载调节&#xff0c;而不需要任何回路补偿或高侧电流传感。输出的…
阅读更多...
VB：二分法查找

VB：二分法查找

VB&#xff1a;二分法查找 二分查找算法 Private Sub Command1_Click()Dim i%, m%, n%Dim x(1 To 10) As SingleFor i 1 To 10x(i) Val(InputBox("请输入"))Next iCall bubbleSort(x)For i LBound(x) To UBound(x) LBound(x)和UBound(x)是用于获取数组x的下界和上…
阅读更多...
运营技巧｜如何在不同的平台上高效批量管理账户？

运营技巧｜如何在不同的平台上高效批量管理账户？

在当今全球化时代&#xff0c;中国出海企业和B2B外贸企业越来越重视海外社媒营销&#xff0c;这已成为企业抢占市场份额的关键。并且&#xff0c;为了获取到更多流量&#xff0c;跨境人们还会开通Facebook、Twitter、Google、TikTok、Instagram等平台账号&#xff0c;搭建自己的…
阅读更多...
教你制作作业查询系统

教你制作作业查询系统

嗨&#xff0c;各位老师们&#xff0c;今天我要给你们介绍一个超级方便的工具——易查分&#xff01;你知道吗&#xff0c;利用易查分&#xff0c;我们可以轻松制作一个便捷高效的作业查询系统哦&#xff01; 是不是想有个自己的分班or成绩查询页面&#xff1f;博主给老师们争取…
阅读更多...
提醒一个xampp启动mysql创建函数存在的坑

提醒一个xampp启动mysql创建函数存在的坑

一直以来本地搭建的项目为了方便我都是使用xampp作为mysql的管理工具&#xff0c;比较简洁可视化比较好。但是最近程序的一个报错暴露了他与mysql之间的一些问题。 使用自增序列nextval函数时&#xff0c;突然抛出来一句&#xff1a; select nextval( SEQ_REGISTER_ID) > …
阅读更多...
高性能数据JS网格 Bryntum Grid 5.5.2 Crack

高性能数据JS网格 Bryntum Grid 5.5.2 Crack

高性能数据网格 Bryntum Grid 是一个高性能的网络表格组件。它是用纯 JavaScript 构建的&#xff0c;并且可以轻松地与所有主要 JS 框架集成。 功能丰富 Bryntum Grid 具有您期望从专业网格组件获得的所有功能&#xff0c;包括&#xff1a; 很好的表现;很好的绩效 没有人喜欢缓…
阅读更多...
演讲实录：大模型时代，我们需要什么样的AI算力系统？

演讲实录：大模型时代，我们需要什么样的AI算力系统？

当前&#xff0c;“百模大战”带来了算力需求的爆发&#xff0c;AI芯片产业也迎来巨大机遇&#xff0c;“创新架构开源生态”正在激发多元AI算力产品百花齐放。面对新的产业机会&#xff0c;AI算力产业链亟需通过上下游协作共同把握机遇。 近日&#xff0c;浪潮信息AI&HPC…
阅读更多...
异步FIFO设计的仿真与综合技术（1）

异步FIFO设计的仿真与综合技术（1）

概述 本文主体翻译自C. E. Cummings and S. Design, “Simulation and Synthesis Techniques for Asynchronous FIFO Design 一文&#xff0c;添加了笔者的个人理解与注释&#xff0c;文中蓝色部分为笔者注或意译。 摘要&#xff08;ABSTRACT&#xff09; FIFO通常被用于将数据…
阅读更多...
万物目标识别——Detic使用图像级别的监督信号来进行目标检测模型推理（C++/Python）

万物目标识别——Detic使用图像级别的监督信号来进行目标检测模型推理（C++/Python）

一、目标识别 1.1 传统目标识别算法 传统目标检测通常将分类&#xff08;确定物体属于哪个类别&#xff09;和定位&#xff08;确定物体的位置&#xff0c;通常使用边界框bbox表示&#xff09;任务耦合在一起。这要求训练数据集中包含每个物体的类别标签以及其对应的bbox位置…
阅读更多...
【开发】视频监控平台EasyCVR分组批量绑定/取消通道功能的后端代码设计逻辑介绍

【开发】视频监控平台EasyCVR分组批量绑定/取消通道功能的后端代码设计逻辑介绍

视频监控平台/视频存储/视频分析平台EasyCVR基于云边端一体化管理&#xff0c;可支持视频实时监控、云端录像、云存储、磁盘阵列存储、回放与检索、智能告警、平台级联等功能。安防监控平台在线下场景中应用广泛&#xff0c;包括智慧工地、智慧工厂、智慧校园、智慧社区等等。 …
阅读更多...
【Flink实战】玩转Flink里面核心的Sink Operator实战

【Flink实战】玩转Flink里面核心的Sink Operator实战

&#x1f680; 作者 &#xff1a;“大数据小禅” &#x1f680; 文章简介 &#xff1a;玩转Flink里面核心的Sink Operator实战 &#x1f680; 欢迎小伙伴们 点赞&#x1f44d;、收藏⭐、留言&#x1f4ac; 目录导航 Flink Sink Operator简介Flink 核心知识 Sink Operator速览Fl…
阅读更多...
便捷高效的查询系统

便捷高效的查询系统

今天我要来给大家种草一个超级好用的教学工具——易查分&#xff01;使用易查分&#xff0c;老师们可以轻松制作一个方便快捷的成绩查询系统&#xff0c;让查询成绩变得简单又高效。下面就让我来为大家详细介绍一下使用教程吧&#xff01; 是不是想有个自己的分班or成绩查询页面…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023