【C++】unordered_set和unordered_map的封装（哈希）

news2024/9/27 15:25:37

 🌈个人主页：秦jh_-CSDN博客
🔥 系列专栏：https://blog.csdn.net/qinjh_/category_12575764.html?spm=1001.2014.3001.5482

 9efbcbc3d25747719da38c01b3fa9b4f.gif​ 

目录

key和pair 

 仿函数hash

迭代器

operator++

HashTable.h

my_unordered_map.h

my_unordered_set.h

前言

    💬 hello! 各位铁子们大家好哇。

             今日更新了unordered_map和unordered_set封装的相关内容
    🎉 欢迎大家关注🔍点赞👍收藏⭐️留言📝

key和pair 

前面已经实现了哈希的底层，现用哈希进行封装。

unordered_set和unordered_map的封装和map、set大体思路一样。hash是底层，他并不知道传入的是k还是pair，但是上层的unordered_set和unordered_map知道。所以在hash多传入一个模板参数KeyOfT，这样再在map和set中分别实现取出key的逻辑即可。

 仿函数hash

 由于hash现在是底层，我们的仿函数不可能直接传给hash底层，所以得在unordered_set和unordered_map上传多一个模板参数，这样取模的仿函数就可以在外面传了。

迭代器

当遍历完一个桶后，准备找下一个桶时，就需要有哈希表，不然就找不到下一个桶，所以iterator需要传第二个参数：哈希表的指针。

operator++

当当前桶走完了，就要找下一个不为空的桶的第一个节点。循环结束有两种可能，一：所有桶都走完了。二：找到下一个不为空的桶。

HashTable.h

#pragma once 
#include<vector>

template<class K>
struct HashFunc
{
	size_t operator()(const K& key)
	{
		return (size_t)key; //负数、指针都能转
	}
};

//特化
template<>
struct HashFunc<string>
{
	size_t operator()(const string& key)
	{
		size_t hash = 0;
		for (auto ch : key)
		{
			hash *= 131;
			hash += ch;
		}
		return hash;
	}
};

namespace open_address
{
	enum State
	{
		EMPTY,
		EXIST,
		DELETE
	};

	template<class K, class V>
	struct HashData
	{
		pair<K, V> _kv;
		State _state = EMPTY;
	};

	template<class K, class V, class Hash = HashFunc<K>>
	class HashTable
	{
	public:
		HashTable()
		{
			_tables.resize(10);
		}

		bool Insert(const pair<K, V>& kv)
		{
			if (Find(kv.first))  //不允许冗余
				return false;

			//扩容
			if (_n * 10 / _tables.size() >= 7)
			{
				//方法一
				//size_t newsize = _tables.size() * 2;    //用vector的话需要手动映射
				//vector<HashData<K, V>> newtables(newsize);

				旧表重新计算负载到新表
				//for(size_t i=0;i<_tables.size();i++)
				//{ }

				//方法二
				HashTable<K, V, Hash> newHT;
				newHT._tables.resize(_tables.size() * 2);

				//旧表重新计算负载到新表
				for (size_t i = 0; i < _tables.size(); i++)
				{
					if (_tables[i]._state == EXIST)
					{
						newHT.Insert(_tables[i]._kv);//用HashTable对象插入，可以复用Insert，不需要手动映射
					}								 //newHT已经是扩容好的了，就跳过扩容，直接来到探测部分
				}									 //新表插入好后，再跟旧表互换
				_tables.swap(newHT._tables);
			}
			Hash hs;
			size_t hashi = hs(kv.first) % _tables.size();  //不能模capacity,否则会得到比size大的数，而size后面的位置不能用[]得到
			//线性探测
			while (_tables[hashi]._state == EXIST)
			{
				++hashi;
				hashi %= _tables.size(); //如果往后找找不到，就回到前面继续找
			}

			_tables[hashi]._kv = kv;
			_tables[hashi]._state = EXIST;
			++_n;

			return true;
		}

		HashData<K, V>* Find(const K& key)
		{
			Hash hs;
			size_t hashi = hs(key) % _tables.size();
			//线性探测
			while (_tables[hashi]._state != EMPTY)
			{
				if (_tables[hashi]._state == EXIST &&
					_tables[hashi]._kv.first == key)
				{
					return &_tables[hashi];
				}
				++hashi;
				hashi %= _tables.size();
			}
			return nullptr;
		}

		bool Erase(const K& key)
		{
			HashData<K, V>* ret = Find(key);
			if (ret == nullptr)
			{
				return false;
			}
			else
			{
				ret->_state = DELETE;
				--_n;
				return true;
			}
		}

	private:
		vector<HashData<K, V>> _tables;
		size_t _n = 0; //有效数据个数
	};

	void TestHT1()
	{
		int a[] = { 10001,11,55,24,19,12,31 };
		HashTable<int, int> ht;
		for (auto e : a)
		{
			ht.Insert(make_pair(e, e));
		}

		cout << ht.Find(55) << endl;
		cout << ht.Find(31) << endl;

		ht.Erase(55);
		cout << ht.Find(55) << endl;
		cout << ht.Find(31) << endl;
	}

	void TestHT2()
	{
		int a[] = { 10001,11,55,24,19,12,31 };
		HashTable<int, int> ht;
		for (auto e : a)
		{
			ht.Insert(make_pair(e, e));
		}

		ht.Insert(make_pair(32, 32));
		ht.Insert(make_pair(32, 32));
	}

	//如果key不支持强转成整形取模，就要自己提供转换成整形的仿函数
	void TestHT3()
	{
		HashTable<string, int> ht;
		ht.Insert(make_pair("sort", 1));
		ht.Insert(make_pair("left", 1));
		ht.Insert(make_pair("insert	", 1));

		//cout << StringHashFunc()("abcd") << endl;
		//cout << StringHashFunc()("aadd") << endl;

	}
}


namespace hash_bucket
{
	template<class T>
	struct HashNode
	{
		T _data;
		HashNode<T>* _next;

		HashNode(const T& data)
			:_data(data)
			,_next(nullptr)
		{}
	};

	//前置声明
	//HashTable需要用到__HTIterator，__HTIterator也需要用到HashTable
	//所以只能用前置声明
	template<class K, class T, class KeyOfT, class Hash >
	class HashTable;

	//template<class K, class T,class KeyOfT, class Hash >
	//struct __HTIterator
	//{
	//	typedef HashNode<T> Node;
	//	typedef __HTIterator<K, T, KeyOfT, Hash> Self;

	//	Node* _node;
	//	HashTable<K, T, KeyOfT, Hash>* _pht;  //当前桶为空的时候需要找下一个桶，就需要表才能找到下一个桶

	//	__HTIterator(Node* node,HashTable<K,T,KeyOfT,Hash>* pht)
	//		:_node(node)
	//		,_pht(pht)
	//	{}

	//	T& operator*()
	//	{
	//		return _node->_data;
	//	}

	//	T* operator->()
	//	{
	//		return &_node->_data;
	//	}

	//	Self operator++()
	//	{
	//		if (_node->_next)
	//		{
	//			//当前桶没走完，找当前桶的下一个节点
	//			_node = _node->_next;
	//		}
	//		else
	//		{
	//			//当前桶走完了，找下一个不为空的桶的第一个节点
	//			KeyOfT kot;
	//			Hash hs;
	//			size_t i = hs(kot(_node->_data)) % _pht->_tables.size(); 
	//			++i;
	//			for (; i < _pht->_tables.size(); i++)
	//			{
	//				if (_pht->_tables[i])
	//					break;
	//			}

	//			if (i == _pht->_tables.size())
	//			{
	//				//所有桶都走完了，最后一个的下一个用nullptr标记
	//				_node = nullptr;
	//			}
	//			else
	//			{
	//				_node = _pht->_tables[i];
	//			}
	//		}
	//		return *this;
	//	}

	//	bool operator!=(const Self& s)
	//	{
	//		return _node != s._node;
	//	}
	//};


	template<class K ,class T,class KeyOfT, class Hash >
	class HashTable
	{
		typedef HashNode<T> Node;
	public:
		//__HTIterator需要访问HashTable的私有，所以用友元
		/*template<class K, class T, class KeyOfT, class Hash >
		friend struct __HTIterator;*/

		//内部类
		template<class Ptr, class Ref>
		struct __HTIterator 
		{
			typedef HashNode<T> Node;
			typedef __HTIterator Self;

			Node* _node;
			const HashTable* _pht;  //当前桶为空的时候需要找下一个桶，就需要表才能找到下一个桶

			__HTIterator(Node* node,const HashTable* pht)
				:_node(node)
				,_pht(pht)
			{}

			Ref operator*()
			{
				return _node->_data;
			}

			Ptr operator->()
			{
				return &_node->_data;
			}

			Self operator++()
			{
				if (_node->_next)
				{
					//当前桶没走完，找当前桶的下一个节点
					_node = _node->_next;
				}
				else
				{
					//当前桶走完了，找下一个不为空的桶的第一个节点
					KeyOfT kot;
					Hash hs;
					size_t i = hs(kot(_node->_data)) % _pht->_tables.size(); 
					++i;
					for (; i < _pht->_tables.size(); i++)
					{
						if (_pht->_tables[i])
							break;
					}

					if (i == _pht->_tables.size())
					{
						//所有桶都走完了，最后一个的下一个用nullptr标记
						_node = nullptr;
					}
					else
					{
						_node = _pht->_tables[i];
					}
				}
				return *this;
			}

			bool operator!=(const Self& s)
			{
				return _node != s._node;
			}
		};

		
		
		typedef __HTIterator<T*,T&> iterator;
		typedef __HTIterator<const T*,const T&> const_iterator;
		

		iterator begin()
		{
			for (size_t i = 0; i < _tables.size(); i++)
			{
				Node* cur = _tables[i];
				if (cur)
				{	//this ->HashTable*			//begin写在HashTable里面，
					return iterator(cur, this);//this：返回的是哈希表的指针
				}
			}
			return end();
		}

		iterator end()
		{
			return iterator(nullptr, this);
		}

		const_iterator begin()const
		{
			for (size_t i = 0; i < _tables.size(); i++)
			{
				Node* cur = _tables[i];
				if (cur)
				{	//this ->const HashTable*			//begin写在HashTable里面，
					return const_iterator(cur, this);//this：返回的是哈希表的指针
				}
			}
			return end();
		}

		const_iterator end()const 
		{
			return const_iterator(nullptr, this);
		}

		HashTable()
		{
			_tables.resize(10, nullptr);
			_n = 0;
		}
		
		~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;
			}
		}

		pair<iterator,bool> Insert(const T& data)
		{
			KeyOfT kot;
			iterator it = Find(kot(data));
			if (it!= end())
				return make_pair(it,false);

			Hash hs;
			//扩容
			//负载因子为1时扩容
			if (_n == _tables.size())
			{
				//HashTable<K, V> newHT;
				//newHT._tables.resize(_tables.size() * 2);

				旧表重新计算负载到新表
				//for (size_t i = 0; i < _tables.size(); i++)
				//{
				//	Node* cur = _tables[i];
				//	while(cur)
				//	{
				//		newHT.Insert(cur->_kv);
				//		cur = cur->_next;
				//	}								 
				//}									
				//_tables.swap(newHT._tables);

				vector<Node*> newTables(_tables.size() * 2, nullptr); 
				for (size_t i = 0; i < _tables.size(); i++) 
				{
					Node* cur = _tables[i];  
					while(cur)
					{ 
						Node* next = cur->_next;  
						//头插到新表的位置
						size_t hashi = hs(kot(cur->_data)) % newTables.size(); 
						cur->_next = newTables[hashi];   
						newTables[hashi] = cur;   

						cur = next; 
					}				 
					_tables[i] = nullptr; 
				}									
				_tables.swap(newTables);  
			}

			size_t hashi = hs(kot(data)) % _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)
		{
			KeyOfT kot;
			Hash hs;
			size_t hashi = hs(key) % _tables.size();
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (kot(cur->_data) == key)
				{
					return iterator(cur,this);
				}
				cur = cur->_next;
			}
			return end();
		}

		bool Erase(const K& key)
		{
			KeyOfT kot; 
			Hash hs;
			size_t hashi = hs(key) % _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;
				}
				else
				{
					prev = cur;
					cur = cur->_next;
				}
			}
			return false;
		}

	private:
		vector<Node*> _tables;  //指针数组
		size_t _n;
		
		//vector<list<pair<K, V>>> _tables;
	};

	/*void TestHT1()
	{
		int a[] = { 10001,11,55,24,19,12,31,4,34,44 };
		HashTable<int, int> ht;
		for (auto e : a)
		{
			ht.Insert(make_pair(e, e));
		}

		ht.Insert(make_pair(32, 32));
		ht.Insert(make_pair(32, 32));

		ht.Erase(31);
		ht.Erase(11);

	}

	void TestHT2()
	{
		HashTable<string, int> ht; 
		ht.Insert(make_pair("sort", 1));
		ht.Insert(make_pair("left", 1));
		ht.Insert(make_pair("insert	", 1));
	}*/

}

my_unordered_map.h

#pragma once


namespace qjh
{
	template<class K,class V, class Hash = HashFunc<K>>
	class unordered_map
	{
		struct MapKeyOfT 
		{
			const K& operator()(const pair<K, V>& kv) 
			{
				return kv.first; 
			} 
		};

	public:
		typedef typename hash_bucket::HashTable<K, pair<const K,V>, MapKeyOfT, Hash >::iterator iterator; 
		typedef typename hash_bucket::HashTable<K, pair<const K, V>, MapKeyOfT, Hash >::const_iterator const_iterator;

		iterator begin()
		{
			return _ht.begin();
		}

		iterator end()
		{
			return _ht.end();
		}

		const_iterator begin() const
		{
			return _ht.begin();
		}

		const_iterator end() const
		{
			return _ht.end();
		}

		V& operator[](const K& key)
		{
			pair<iterator, bool> ret = insert(make_pair(key, V()));
			return ret.first->second;
		}

		pair<iterator, bool> insert(const pair<K, V>& key)
		{
			return _ht.Insert(key);
		}

	private:
		hash_bucket::HashTable<K, pair<const K, V>, MapKeyOfT,Hash > _ht;
		
	};
	

	void test_unordered_map1()
	{
		string arr[] = { "苹果","西瓜","苹果","西瓜","苹果","苹果","西瓜",
			"苹果","香蕉","苹果","香蕉","苹果","草莓","苹果","草莓" };
		unordered_map<string, int> countmap;
		for (auto& e : arr)
		{
			countmap[e]++;
		}

		unordered_map<string,int>::iterator it = countmap.begin();
		while (it != countmap.end())
		{
			//it->first += 'x';  //key不能修改
			it->second += 1;     //value可以修改
			cout << it->first << ":" << it->second << endl;
			++it;
		}
		cout << endl;

		for (auto& kv : countmap)
		{
			cout << kv.first << ":" << kv.second << endl;
		}
		cout << endl;
	}
}

my_unordered_set.h

#pragma once

#include"HashTable.h"

namespace qjh
{
	template<class K,class Hash = HashFunc<K>>
	class unordered_set
	{
		struct SetKeyOfT
		{
			const K& operator()(const K& key) 
			{
				return key; 
			}
		};

	public:
		typedef typename hash_bucket::HashTable<K, const K, SetKeyOfT, Hash>::iterator iterator;
		typedef typename hash_bucket::HashTable<K, const K, SetKeyOfT, Hash>::const_iterator const_iterator;

		iterator begin()
		{
			return _ht.begin();
		}

		iterator end()
		{
			return _ht.end();
		}

		const_iterator begin() const
		{
			return _ht.begin();
		}

		const_iterator end() const
		{
			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:
		hash_bucket::HashTable<K,const K, SetKeyOfT, Hash> _ht;
	};

	void Func(const unordered_set<int>& s)
	{
		unordered_set<int>::iterator it = s.begin();
		while (it != s.end())
		{
			//*it = 1;
			cout << *it << " ";
			++it;
		}
		cout << endl;
	}

	void test_unordered_set()
	{
		unordered_set<int> s;
		s.insert(31);
		s.insert(11);
		s.insert(5);
		s.insert(15);
		s.insert(25);

		unordered_set<int>::iterator it = s.begin();
		while (it != s.end())
		{
			//*it = 1;
			cout << *it << " ";
			++it;
		}
		cout << endl;

		for (auto e : s)
		{
			cout << e << " ";
		}
		cout << endl;
	}
}

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

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

相关文章

【自动驾驶】控制算法（一）绪论与前期准备

【自动驾驶】控制算法（一）绪论与前期准备

写在前面&#xff1a; &#x1f31f; 欢迎光临 清流君 的博客小天地&#xff0c;这里是我分享技术与心得的温馨角落。&#x1f4dd; 个人主页&#xff1a;清流君_CSDN博客&#xff0c;期待与您一同探索 移动机器人 领域的无限可能。 &#x1f50d; 本文系 清流君 原创之作&…
阅读更多...
白盒测试-发送请求

白盒测试-发送请求

发送请求-怎么操作&#xff1f; 先创建发送请求对象mockmvc--用mockmvc对象发送请求&#xff08;包含请求url,请求头&#xff0c;请求参数等&#xff09; 用到的源码是mockmvc源码--其中perform方法&#xff0c;他的入参是接口类 用mockmvc对象发送请求&#xff0c;代码是mock…
阅读更多...
【机器学习第11章——特征选择与稀疏学习】

【机器学习第11章——特征选择与稀疏学习】

机器学习第11章——特征选择与稀疏学习 11.特征选择与稀疏学习11.1子集搜索与评价子集搜索子集评价 11.2 过滤式选择11.3 包裹式选择11.4 嵌入式选择11.5 稀疏表示与字典学习稀疏表示字典学习 11.6 压缩感知 11.特征选择与稀疏学习 11.1子集搜索与评价 特征&#xff1a;描述物…
阅读更多...
全国计算机二级Python学习笔记

全国计算机二级Python学习笔记

格式化操作符辅助指令: 格式化输出16进制&#xff0c;十进制&#xff0c;八进制整数 %x — hex 十六进制 %d — dec 十进制 %o — oct 八进制 turtle.setup()函数用于启动一个图形窗口&#xff0c;它有四个参数 turtle.setup(width, height, startx, starty) 分别是&…
阅读更多...
kali实用工具之ettercap

kali实用工具之ettercap

ettercap最初是交换局域网的嗅探器&#xff0c;但在开发的过程中&#xff0c;它获得了越来越多的功能&#xff0c;从而使其转变为强大而灵活的中间人攻击工具。它支持许多协议&#xff08;甚至是加密协议&#xff09;的主动和被动解剖&#xff0c;并包括许多用于网络和主机分析…
阅读更多...
Unity音频管理器插件AudioToolKit

Unity音频管理器插件AudioToolKit

Unity音频管理器插件AudioToolKit 介绍AudioToolKit介绍具体用法总结 介绍 最近在自己写音频管理器的时候在网上发现了一款比较好用并且功能很全的一个音频管理插件&#xff0c;叫做AudioToolKit的插件。 如果需要的可以直接从我资源中找AudioToolKit。 AudioToolKit介绍 A…
阅读更多...
助农扶贫小程序的设计

助农扶贫小程序的设计

管理员账户功能包括&#xff1a;系统首页&#xff0c;个人中心&#xff0c;用户管理&#xff0c;商品信息管理&#xff0c;订单信息管理&#xff0c;订单配送管理&#xff0c;商品评价管理&#xff0c;商品退货管理&#xff0c;管理员管理 微信端账号功能包括&#xff1a;系统…
阅读更多...
Flink消费Kafka数据积压排查解决

Flink消费Kafka数据积压排查解决

0、背景 有个Flink任务每天不定时会出现数据积压&#xff0c;无论是白天还是数据量很少的夜里&#xff0c;且积压的数据量会越来越多&#xff0c;得不到缓解&#xff0c;只能每日在积压告警后重启&#xff0c;重启之后消费能力一点毛病没有&#xff0c;积压迅速缓解&#xff0…
阅读更多...
性能测试常见面试问题汇总

性能测试常见面试问题汇总

性能测试是什么&#xff1f; 答&#xff1a;性能测试是评估系统或应用程序在不同负载条件下的表现的过程。它可以帮助我们确定系统在正常使用期间所需的资源&#xff0c;并找出系统在何时无法满足用户需求的瓶颈。 性能测试包括哪些方面&#xff1f; 答&#xff1a;性能测试包括…
阅读更多...
计算中间件平台之Linkis

计算中间件平台之Linkis

Linkis 是由WeBank自主研发的一款面向大数据和AI的计算中间件平台。它的设计初衷是为了简化和统一各种计算引擎的调用和管理&#xff0c;降低使用大数据和AI技术的门槛。Linkis可以帮助用户在一个平台上方便地调用各种数据处理引擎&#xff0c;如Hadoop、Spark、Hive、Flink等&…
阅读更多...
bridge资产导入blender错误 显示bidge Could not send data over port 28888

bridge资产导入blender错误 显示bidge Could not send data over port 28888

bridge资产导入blender错误 显示bidge Could not send data over port 28888 解决办法 1.在Quixel bridge里点击Edit找到Manage Plugins下载blender插件 我的显示已经下载好了 2.在Quixel bridge里点击Edit找到Settings找到插件保存路径 3.在路径里找到E:\Documents\Mega…
阅读更多...
HTML5服装电商网上商城模板源码

HTML5服装电商网上商城模板源码

文章目录 1.设计来源1.1 主界面1.2 购物车界面1.3 电子产品界面1.4 商品详情界面1.5 联系我们界面1.6 各种标签演示界面 2.效果和源码2.1 动态效果2.2 源代码 源码下载万套模板&#xff0c;程序开发&#xff0c;在线开发&#xff0c;在线沟通 【博主推荐】&#xff1a;前些天发…
阅读更多...
STM32——I2C协议以及软件读写

STM32——I2C协议以及软件读写

I2C协议中SCL用于同布&#xff0c;当某一方发送/接收数据时&#xff0c;另一方将会发应答表示数据已收到。 一主多从&#xff1a;类似于老师是主在讲课&#xff0c;学生是从机&#xff0c;只有老师点名学生才能应答&#xff0c;否则不能自己应答。 之后是硬件电路的设置 对于…
阅读更多...
【ACL2024】面向Stable Station的交互式多轮Prompt生成模型DiffChat

【ACL2024】面向Stable Station的交互式多轮Prompt生成模型DiffChat

近日&#xff0c;阿里云人工智能平台PAI与华南理工大学金连文教授团队合作&#xff0c;在自然语言处理顶级会议 ACL 2024 上发表论文《DiffChat: Learning to Chat with Text-to-Image Synthesis Models for Interactive Image Creation. ACL 2024》。DiffChat算法是一个文到文…
阅读更多...
【活动议题介绍】2024-08-25 | PowerData 数字经济·杭州开源行

【活动议题介绍】2024-08-25 | PowerData 数字经济·杭州开源行

【活动议题介绍】2024-08-25 | PowerData 数字经济杭州开源行 活动介绍议题介绍活动信息扫码报名往期开源行回顾 活动介绍 “总把西湖比西子&#xff0c;浓妆淡抹总相宜”&#xff0c;杭州&#xff0c;这座温婉如画的江南水乡&#xff0c;自古便以其独有的风姿吸引着无数文人墨…
阅读更多...
【C++报错已解决】`RuntimeError: CUDA error: invalid device ordinal`

【C++报错已解决】`RuntimeError: CUDA error: invalid device ordinal`

&#x1f3ac; 鸽芷咕&#xff1a;个人主页 &#x1f525; 个人专栏: 《C干货基地》《粉丝福利》 ⛺️生活的理想&#xff0c;就是为了理想的生活! 引言 你是否在运行CUDA程序时遇到了RuntimeError: CUDA error: invalid device ordinal这样的错误&#xff1f;这通常是由于设…
阅读更多...
STM32标准库学习笔记-9.DMA 直接存储器存取

STM32标准库学习笔记-9.DMA 直接存储器存取

参考教程&#xff1a;【STM32入门教程-2023版 细致讲解 中文字幕】 DMA&#xff08;Direct Memory Access&#xff09; DMA&#xff08;Direct Memory Access&#xff09;直接存储器存取DMA可以提供外设和存储器或者存储器和存储器之间的高速数据传输&#xff0c;无须CPU干预…
阅读更多...
OpenCV图像滤波(20)模糊处理函数stackBlur()的使用

OpenCV图像滤波(20)模糊处理函数stackBlur()的使用

操作系统&#xff1a;ubuntu22.04 OpenCV版本&#xff1a;OpenCV4.9 IDE:Visual Studio Code 编程语言&#xff1a;C11 算法描述 stackBlur() 函数用于对图像进行模糊处理。该函数对图像应用了 stackBlur 技术。stackBlur 可以生成与高斯模糊相似的结果&#xff0c;而且随着模…
阅读更多...
ICMAN水位接近式检测方案（非接触式）

ICMAN水位接近式检测方案（非接触式）

ICMAN水位液位接近式检测方案&#xff08;非接触式&#xff09; 我们的很多家用电器都会需要&#xff1a;液位检测 缺水&溢水提醒保护、高低液位提醒 液位传感器 像健康家电——烧水煮茶熬养生汤的烧水壶、豆浆机、养生壶等需要缺水保护和防溢液提醒&#xff1b; 像清洁…
阅读更多...
ArcGis在线地图插件Maponline（好用版）

ArcGis在线地图插件Maponline（好用版）

ArcGis加载插件&#xff0c;可在线浏览谷歌地图、天地图、高德地图、必应地图等多种&#xff0c;包含街道、影像、标注地图等信息&#xff08;谷歌地图需自备上网手段&#xff09;&#xff0c;免费注册账号即可使用&#xff0c;可加载无水印底图。 与大地2000坐标无需配准直接使…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023