【C++】如何用一个哈希表同时封装出unordered_set与unordered_map

news2024/11/19 0:47:56

👀樊梓慕：个人主页

 🎥个人专栏：《C语言》《数据结构》《蓝桥杯试题》《LeetCode刷题笔记》《实训项目》《C++》《Linux》《算法》

🌝每一个不曾起舞的日子，都是对生命的辜负

目录

前言

1.哈希桶源码

 2.哈希表模板参数的控制

3.字符串作为键值如何映射哈希值

3.1BKDRHash算法

4.封装

4.1构造函数

4.拷贝构造 

4.2析构函数

4.3赋值运算符重载

4.4正向迭代器

4.4.1定义 

4.4.2构造 

4.4.3重载解引用*操作符

4.4.4重载箭头->操作符

4.4.5重载==与!=操作符

4.4.6重载前置++操作符

5.源码

哈希表与迭代器封装源码

MyUnordered_set源码

MyUnordered_map源码

测试源码

前言

上次我们模拟实现了闭散列的哈希表与开散列的哈希表，但很明显上次实现的很粗糙功能很简单，迭代器并没有实现，以及泛型编程思想也没有应用，那么对于本篇文章我们要用一个哈希表同时封装出unordered_set 与 unordered_map，对此我们之前已经成功用一颗红黑树同时封装出set与map，大致的思想是类似的，只不过这里会略微复杂一些。

欢迎大家📂收藏📂以便未来做题时可以快速找到思路，巧妙的方法可以事半功倍。 

=========================================================================

GITEE相关代码：🌟樊飞 (fanfei_c) - Gitee.com🌟

=========================================================================

1.哈希桶源码

//每个哈希桶中存储数据的结构
template<class K, class V>
struct HashNode
{
	pair<K, V> _kv;
	HashNode<K, V>* _next;

	//构造函数
	HashNode(const pair<K, V>& kv)
		:_kv(kv)
		, _next(nullptr)
	{}
};


//哈希表
template<class K, class V>
class HashTable
{
public:
	typedef HashNode<K, V> Node;

	//插入函数
	bool Insert(const pair<K, V>& kv)
	{
		//1、查看哈希表中是否存在该键值的键值对
		if (Find(kv.first)) //哈希表中已经存在该键值的键值对（不允许数据冗余）
		{
			return false; //插入失败
		}

		//2、判断是否需要调整哈希表的大小
		if (_n == _tables.size()) //负载因子超过1
		{
			//增容
			//a、创建一个新的哈希表，新哈希表的大小设置为原哈希表的2倍
			vector<Node*> newTables(_tables.size() * 2, nullptr);

			//b、将原哈希表当中的结点插入到新哈希表
			for (size_t i = 0; i < _tables.size(); i++)
			{
				//取出旧表中的节点，重新计算挂到新表桶中
				Node* cur = _tables[i];
				while (cur)
				{
					Node* next = cur->_next;
					size_t hashi = cur->_kv.first % newTables.size();

					//将该结点头插到新哈希表中编号为index的哈希桶中
					cur->_next = newTables[hashi];
					newTables[hashi] = cur;

					cur = next;
				}
				_tables[i] = nullptr; //该桶取完后将该桶置空

			}
			//c、交换这两个哈希表
			_tables.swap(newTables);
		}

		//3、将键值对插入哈希表
		size_t hashi = kv.first % _tables.size(); //通过哈希函数计算出对应的哈希桶编号index（除数不能是capacity）
		Node* newnode = new Node(kv); //根据所给数据创建一个待插入结点

		//将该结点头插到新哈希表中编号为index的哈希桶中
		newnode->_next = _tables[hashi];
		_tables[hashi] = newnode;

		//4、哈希表中的有效元素个数加一
		_n++;
		return true;
	}

	//查找函数
	HashNode<K, V>* Find(const K& key)
	{
		if (_tables.size() == 0) //哈希表大小为0，查找失败
		{
			return nullptr;
		}

		size_t hashi = key % _tables.size();

		//遍历编号为index的哈希桶
		HashNode<K, V>* cur = _tables[hashi];
		while (cur) //直到将该桶遍历完为止
		{
			if (cur->_kv.first == key) //key值匹配，则查找成功
			{
				return cur;
			}
			cur = cur->_next;
		}
		return nullptr; //直到该桶全部遍历完毕还没有找到目标元素，查找失败
	}

	//删除函数
	bool Erase(const K& key)
	{
		//1、通过哈希函数计算出对应的哈希桶编号hashi（除数不能是capacity）
		size_t hashi = key % _tables.size();
		//2、在编号为index的哈希桶中寻找待删除结点
		Node* prev = nullptr;
		Node* cur = _tables[hashi];
		while (cur) //直到将该桶遍历完为止
		{
			if (cur->_kv.first == key) //key值匹配，则查找成功
			{
				//3、若找到了待删除结点，则删除该结点
				if (prev == nullptr) //待删除结点是哈希桶中的第一个结点
				{
					_tables[hashi] = cur->_next; //将第一个结点从该哈希桶中移除
				}
				else //待删除结点不是哈希桶的第一个结点
				{
					prev->_next = cur->_next; //将该结点从哈希桶中移除
				}
				delete cur; //释放该结点
				//4、删除结点后，将哈希表中的有效元素个数减一
				_n--;
				return true; //删除成功
			}
			prev = cur;
			cur = cur->_next;
		}
		return false; //直到该桶全部遍历完毕还没有找到待删除元素，删除失败
	}

private:
	vector<Node*> _tables; //哈希表
	size_t _n = 0; //哈希表中的有效元素个数
};

 2.哈希表模板参数的控制

template<class K, class T>
class HashTable

那么对于unordered_set：

template<class K>
class unordered_set
{
public:
	//...
private:
	HashTable<K, K> _ht; //传入底层哈希表的是K和K
};

 对于unordered_map：

template<class K, class V>
class unordered_map
{
public:
	//...
private:
	HashTable<K, pair<K, V>> _ht; //传入底层哈希表的是K以及K和V构成的键值对
};

即：

而哈希结点的模板参数也应该由原来的K、V变为T：

  • 上层容器是unordered_set时，传入的T是键值，哈希结点中存储的就是键值。
  • 上层容器是unordered_map时，传入的T是键值对，哈希结点中存储的就是键值对。

更改模板参数后，哈希结点的定义如下：

//哈希结点的定义
template<class T>
struct HashNode
{
	T _data;
	HashNode<T>* _next;

	//构造函数
	HashNode(const T& data)
		:_data(data)
		, _next(nullptr)
	{}
};

与红黑树类似，红黑树需要获取 T 中的key值用来比较大小，在哈希映射中，我们需要获得 T 的键值，然后通过哈希函数计算出对应的哈希地址进行映射。

现在由于我们在哈希结点当中存储的数据类型是T，这个T可能就是一个键值，也可能是一个键值对，对于底层的哈希表来说，它并不知道哈希结点当中存储的数据究竟是什么类型，因此需要由上层容器提供一个『 仿函数』，用于获取T类型数据当中的键值。

对于unordered_map ：

template<class K, class V>
class unordered_map
{
	//仿函数
	struct MapKeyOfT
	{
		const K& operator()(const pair<K, V>& kv) //返回键值对当中的键值key
		{
			return kv.first;
		}
	};
public:
	//...
private:
	HashTable<K, pair<K, V>, MapKeyOfT> _ht;
};

而虽然unordered_set容器传入哈希表的T就是键值，但是底层哈希表并不知道上层容器的种类，底层哈希表在获取键值时会统一通过传入的仿函数进行获取，因此unordered_set容器也需要向底层哈希表提供一个仿函数。

对于unordered_set ：

template<class K>
class unordered_set
{
	//仿函数
	struct SetKeyOfT
	{
		const K& operator()(const K& key) //返回键值key
		{
			return key;
		}
	};
public:
	//...
private:
	HashTable<K, K, SetKeyOfT> _ht;
};

因此，底层哈希表的模板参数现在需要增加一个，用于接收上层容器提供的仿函数。

template<class K, class T, class KeyOfT>
class HashTable

3.字符串作为键值如何映射哈希值

上篇文章我在结尾留下一个问题：

除留余数法是映射哈希值的有效方法，但是这里我们考虑的都是整型情况下，那如果是字符串呢？如果key值是字符串，字符串可没办法取余数，而我们最终是一定要实现泛型编程的，我们怎样才能构建出一个通用的映射关系呢？

3.1BKDRHash算法

经过实验，BKDRHash算法无论是在实际效果还是编码实现中，效果都是最突出的。该算法由于在Brian Kernighan与Dennis Ritchie的《The C Programing Language》一书被展示而得名，是一种简单快捷的hash算法，也是Java目前采用的字符串的hash算法。

因此，现在我们需要在哈希表的模板参数中再增加一个『 仿函数』，用于将键值key转换成对应的整型。

template<class K, class T, class KeyOfT, class HashFunc = Hash<K>>
class HashTable

若是上层没有传入该仿函数，我们则使用默认的仿函数，该默认仿函数直接返回键值key即可，但是用字符串作为键值key是比较常见的，因此我们可以针对string类型写一个类模板的『 特化』，此时当键值key为string类型时，该仿函数就会根据BKDRHash算法返回一个对应的整型。

template<class K>
struct Hash
{
	size_t operator()(const K& key) //返回键值key
	{
		return key;
	}
};
//string类型的特化
template<>
struct Hash<string>
{
	size_t operator()(const string& s) //BKDRHash算法
	{
		size_t value = 0;
		for (auto ch : s)
		{
			value = value * 131 + ch;
		}
		return value;
	}
};

4.封装

4.1构造函数

我们知道哈希表在插入之前一定size>0，因为如果size==0就无法计算哈希值，所以我们之前说在构造这里处理，让哈希表创建出来之后就有一定大小的空间。

HashTable()
{
	_tables.resize(10, nullptr); //构造10个大小的空间，默认存放空指针
	_n = 0; //实际存储个数为0
}

4.拷贝构造 

4.2析构函数

因为哈希表当中存储的结点都是new出来的，因此在哈希表被析构时必须进行结点的释放。在析构哈希表时我们只需要依次取出非空的哈希桶，遍历哈希桶当中的结点并进行释放即可。

~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;
	}
}

4.3赋值运算符重载

实现赋值运算符重载函数时，可以通过参数间接调用拷贝构造函数，之后将拷贝构造出来的哈希表和当前哈希表的两个成员变量分别进行交换即可，当赋值运算符重载函数调用结束后，拷贝构造出来的哈希表会因为出了作用域而被自动析构，此时原哈希表之前的数据也就顺势被释放了。

HashTable& operator=(HashTable ht)
{
	//交换哈希表中两个成员变量的数据
	_tables.swap(ht._table);
	swap(_n, ht._n);

	return *this; //支持连续赋值
}

4.4正向迭代器

哈希表的正向迭代器实际上就是对哈希结点指针进行了封装，但是由于在实现++运算符重载时，可能需要在哈希表中去寻找下一个非空哈希桶，因此每一个正向迭代器中都应该存储哈希表的地址。

4.4.1定义 

//正向迭代器
template<class K, class T, class KeyOfT, class Hash = Hash<K>>
struct __HTIterator
{
	typedef HashNode<T> Node; //哈希结点的类型
	typedef HashTable<K, T, KeyOfT, Hash> HT; //哈希表的类型
	typedef __HTIterator<K, T, KeyOfT, Hash> Self; //正向迭代器的类型

	Node* _node; //结点指针
	HT* _ht; //哈希表的地址
};

4.4.2构造 

因此在构造正向迭代器时，我们不仅需要对应哈希结点的指针，还需要该哈希结点所在哈希表的地址。

__HTIterator(Node* node, HT* ht)
	:_node(node)
	, _ht(ht)
{}

4.4.3重载解引用*操作符

T& operator*()
{
	return _node->_data; //返回哈希结点中数据的引用
}

4.4.4重载箭头->操作符

T* operator->()
{
	return &_node->_data; //返回哈希结点中数据的地址
}

4.4.5重载==与!=操作符

bool operator!=(const Self& s) const
{
	return _node != s._node; //判断两个结点的地址是否不同
}

bool operator==(const Self& s) const
{
	return _node == s._node; //判断两个结点的地址是否相同
}

4.4.6重载前置++操作符

前置++的逻辑，我们只需要额外考虑以下可能会换桶的情况即可。

  • 若当前结点不是当前哈希桶中的最后一个结点，则++后走到当前哈希桶的下一个结点。
  • 若当前结点是当前哈希桶的最后一个结点，则++后走到下一个非空哈希桶的第一个结点。
Self& operator++()
{
	if (_node->_next)
	{
		// 当前桶还是节点
		_node = _node->_next;
	}
	else
	{
		// 当前桶走完了，找下一个桶
		KeyOfT kot;
		Hash hs;
		size_t hashi = hs(kot(_node->_data)) % _ht->_tables.size();
		// 找下一个桶
		hashi++;
		while (hashi < _ht->_tables.size())
		{
			if (_ht->_tables[hashi])
			{
				_node = _ht->_tables[hashi];
				break;
			}

			hashi++;
		}

		// 后面没有桶了
		if (hashi == _ht->_tables.size())
		{
			_node = nullptr;
		}
	}

	return *this;
}

 注意： 哈希表的迭代器类型是单向迭代器，没有反向迭代器，所以没有实现–运算符的重载。

5.源码

在具体实现时，需要注意迭代器与哈希表的相互引用，由于迭代器实现在哈希表前面，而编译器只会向前寻找哈希表的定义，所以会发生迭代器不认识哈希表的情况，这是就需要一个前置声明（具体看代码中的体现），而迭代器要访问哈希表中的private成员，所以要在哈希表中声明迭代器为友元。

哈希表与迭代器封装源码

#pragma once

template<class K>
struct HashFunc
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};

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

		return hash;
	}
};

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

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

	// 前置声明
	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 HashTable<K, T, KeyOfT, Hash> HT;
		typedef __HTIterator<K, T, KeyOfT, Hash> Self;

		Node* _node;
		HT* _ht;

		__HTIterator(Node* node, HT* ht)
			:_node(node)
			, _ht(ht)
		{}

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

		Self& operator++()
		{
			if (_node->_next)
			{
				// 当前桶还是节点
				_node = _node->_next;
			}
			else
			{
				// 当前桶走完了，找下一个桶
				KeyOfT kot;
				Hash hs;
				size_t hashi = hs(kot(_node->_data)) % _ht->_tables.size();
				// 找下一个桶
				hashi++;
				while (hashi < _ht->_tables.size())
				{
					if (_ht->_tables[hashi])
					{
						_node = _ht->_tables[hashi];
						break;
					}

					hashi++;
				}

				// 后面没有桶了
				if (hashi == _ht->_tables.size())
				{
					_node = nullptr;
				}
			}

			return *this;
		}

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

	template<class K, class T, class KeyOfT, class Hash>
	class HashTable
	{
		//迭代器要访问哈希表的私有成员，所以要声明友元
		template<class K, class T, class KeyOfT, class Hash>
		friend struct __HTIterator;

		typedef HashNode<T> Node;
	public:
		typedef __HTIterator<K, T, KeyOfT, Hash> iterator;

		iterator begin()
		{
			for (size_t i = 0; i < _tables.size(); i++)
			{
				// 找到第一个桶的第一个节点
				if (_tables[i])
				{
					return iterator(_tables[i], this);
				}
			}

			return end();
		}

		iterator end()
		{
			return 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;
			}
		}

		bool Insert(const T& data)
		{
			KeyOfT kot;

			if (Find(kot(data)))
				return false;

			Hash hs;

			// 负载因子到1就扩容
			if (_n == _tables.size())
			{
				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 true;
		}

		Node* 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 cur;
				}

				cur = cur->_next;
			}

			return nullptr;
		}

		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)
					{
						prev->_next = cur->_next;
					}
					else
					{
						_tables[hashi] = cur->_next;
					}

					delete cur;

					--_n;
					return true;
				}

				prev = cur;
				cur = cur->_next;
			}

			return false;
		}
	private:
		vector<Node*> _tables; // 指针数组
		size_t _n;
	};

}

MyUnordered_set源码

#pragma once

#include"Open_Hash.h"

namespace MyHash
{
	template<class K, class Hash = HashFunc<K>>
	class unordered_set
	{
		struct SetKeyOfT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	public:
		typedef typename Open_Hash::HashTable<K, const K, SetKeyOfT, Hash>::iterator iterator;

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

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

		bool insert(const K& key)
		{
			return _ht.Insert(key);
		}

	private:
		Open_Hash::HashTable<K, const K, SetKeyOfT, Hash> _ht;
	};

	void test_set1()
	{
		unordered_set<int> us;
		us.insert(3);
		us.insert(1);
		us.insert(5);
		us.insert(15);
		us.insert(45);
		us.insert(7);

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

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

MyUnordered_map源码

#pragma once

#include"Open_Hash.h"

namespace MyHash
{
	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 Open_Hash::HashTable<K, pair<const K, V>, MapKeyOfT, Hash>::iterator iterator;

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

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

		bool insert(const pair<K, V>& kv)
		{
			return _ht.Insert(kv);
		}
	private:
		Open_Hash::HashTable<K, pair<const K, V>, MapKeyOfT, Hash> _ht;
	};
	void test_map1()
	{
		unordered_map<string, string> dict;
		dict.insert(make_pair("sort", "排序"));
		dict.insert(make_pair("left", "左面"));
		dict.insert(make_pair("right", "右面"));

		for (auto& kv : dict)
		{
			//kv.first += 'x';
			kv.second += 'y';

			cout << kv.first << ":" << kv.second << endl;
		}
	}
}

测试源码

#include<iostream>
#include<string>
#include<vector>

using namespace std;

#include"Open_Hash.h"

#include"MyUnordered_map.h"
#include"MyUnordered_set.h"

int main()
{
	MyHash::test_set1();
	MyHash::test_map1();
	return 0;
}

=========================================================================

如果你对该系列文章有兴趣的话，欢迎持续关注博主动态，博主会持续输出优质内容

🍎博主很需要大家的支持，你的支持是我创作的不竭动力🍎

🌟~ 点赞收藏＋关注 ~🌟

=========================================================================

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

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

相关文章

19.删除链表的倒数第N个结点 92.反转链表II

19.删除链表的倒数第N个结点 92.反转链表II

给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], n 2 输出&#xff1a;[1,2,3,5]示例 2&#xff1a; 输入&#xff1a;head [1], n 1 输出&#xff1a;[]示例 3&#xff1a; …
阅读更多...
模拟-算法

模拟-算法

文章目录 替换所有的问号提莫攻击Z字形变换外观数列数青蛙 替换所有的问号 算法思路&#xff1a; 从前往后遍历整个字符串&#xff0c;找到问号之后&#xff0c;就遍历 a ~ z 去尝试替换即可。 class Solution {public String modifyString(String s) {char[] ss s.toCharA…
阅读更多...
删除字符串--给你一个字符串S，要求你将字符串中出现的所有“gzu“子串删除，输出删除之后的S。

删除字符串--给你一个字符串S，要求你将字符串中出现的所有“gzu“子串删除，输出删除之后的S。

输入描述: 输入一行字符串S&#xff0c;长度不超过100。 输出描述: 输出进行删除操作之后的S。 #include <stdio.h> #include <stdlib.h> #include <string.h>//结合了串的模式匹配算法思路int main(){char s[100];char a[3]{g,z,u};gets(s);int nstrlen…
阅读更多...
数据库语言一些基本操作

数据库语言一些基本操作

1&#xff0c;消除取值重复的行。 例如&#xff1a;查成绩不及格的学号&#xff1a;SELECT DISTINCT sno FROM SC WHERE grade<60. 这里使用DISTINCT表示取消取值重复的行。 2&#xff0c;比较。 例如&#xff1a;查计算机系全体学生的姓名&#xff1a;SELECT Sname FROM…
阅读更多...
C++一维数组练习oj(3)

C++一维数组练习oj(3)

为什么C的一维数组练习要出要做那么多的题目&#xff1f;因为我们是竞赛学生&#xff01;想要将每个知识点灵活运用的话就必须刷大量的题目来锻炼思维。 我使用的是jsswoj.com这个刷题网站&#xff0c;当然要钱... C一维数组练习oj(2)-CSDN博客这是上一次的题目讲解 这道题有…
阅读更多...
java每日一题——买啤酒(递归经典问题)

java每日一题——买啤酒(递归经典问题)

前言&#xff1a; 非常喜欢的一道题&#xff0c;经典中的经典。打好基础&#xff0c;daydayup!!!啤酒问题&#xff1a;一瓶啤酒2元&#xff0c;4个盖子可以换一瓶&#xff0c;2个空瓶可以换一瓶&#xff0c;请问10元可以喝几瓶 题目如下&#xff1a; 啤酒问题&#xff1a;一瓶…
阅读更多...
[Halcon学习笔记]在Qt上实现Halcon窗口的字体设置颜色设置等功能

[Halcon学习笔记]在Qt上实现Halcon窗口的字体设置颜色设置等功能

1、 Halcon字体大小设置在Qt上的实现 在之前介绍过Halcon窗口显示文字字体的尺寸和样式&#xff0c;具体详细介绍可回看 &#xff08;一&#xff09;Halcon窗口界面上显示文字的字体尺寸、样式修改 当时介绍的设定方法 //Win下QString Font_win "-Arial-10-*-1-*-*-1-&q…
阅读更多...
传输层——UDP协议

传输层——UDP协议

端口号(Port) 端口号标识了一个主机上进行通信的不同的应用程序&#xff0c;准确来说&#xff0c;端口号标识了主机上唯一的一个进程。 在TCP/IP协议中, 用 "源IP", "源端口号", "目的IP", "目的端口号", "协议号" 这样一个…
阅读更多...
罗德与施瓦茨联合广和通全面验证RedCap模组FG132系列先进性能

罗德与施瓦茨联合广和通全面验证RedCap模组FG132系列先进性能

近日&#xff0c;罗德与施瓦茨联合广和通完成Redcap(Reduce Capability)功能和性能验证。本次测试使用R&SCMX500 OBT(One Box Tester)无线通信测试仪&#xff0c;主要验证广和通RedCap模组FG132系列射频性能以及IP层吞吐量&#xff0c;包括RedCap上下行吞吐量和射频指标如矢…
阅读更多...
Java 自定义线程池实现

Java 自定义线程池实现

自定义线程池 简介任务图示阻塞队列 BlockingQueue<T>ReentrantLock代码 线程池 ThreadPool工作线程类 Worker 拒绝策略接口代码测试类 TestThreadPool为什么需要j i&#xff1f;&#xff08;lambad表达式相关&#xff09; 测试结果拒绝策略&#xff1a;让调用者自己执行…
阅读更多...
c++常考基础知识（2）

c++常考基础知识（2）

二.c关键字 关键字汇总 c中共有63个关键字&#xff0c;其中包括int&#xff0c;char&#xff0c;double等类型关键字&#xff0c;if&#xff0c;else&#xff0c;while&#xff0c;do&#xff0c;等语法关键字&#xff0c;还有sizeof等函数关键字。 三.数据结构 1.数组&#x…
阅读更多...
Navicat 干货 | 探索 PostgreSQL 的外部数据包装器和统计函数

Navicat 干货 | 探索 PostgreSQL 的外部数据包装器和统计函数

PostgreSQL 因其稳定性和可扩展性而广受青睐&#xff0c;为开发人员和数据管理员提供了许多有用的函数。在这些函数中&#xff0c;file_fdw_handler、file_fdw_validator、pg_stat_statements、pg_stat_statements_info 以及 pg_stat_statements_reset 是其中的重要函数&#x…
阅读更多...
浩哥带你做项目，纯免费教学

浩哥带你做项目，纯免费教学

浩哥带你做项目 一、YiYi-Web项目开发1. 简介2. 技术栈2.1 后端开发环境2.2 前端开发环境 3.项目截图 二、计算机游戏程序设计&#xff08;基础篇&#xff09;三、RuoYi-Cloud项目学习1.功能介绍2.项目截图 四、鸿蒙应用开发五、软考六、Linux基础知识学习 最近浩哥社区群涌进大…
阅读更多...
【Python从入门到进阶】51、电影天堂网站多页面下载实战

【Python从入门到进阶】51、电影天堂网站多页面下载实战

接上篇《50、当当网Scrapy项目实战&#xff08;三&#xff09;》 上一篇我们讲解了使用Scrapy框架在当当网抓取多页书籍数据的效果&#xff0c;本篇我们来抓取电影天堂网站的数据&#xff0c;同样采用Scrapy框架多页面下载的模式来实现。 一、抓取需求 打开电影天堂网站&…
阅读更多...
VMware Workstation Pro 17虚拟机超级详细搭建（含redis，nacos，docker, rabbitmq，sentinel，elasticsearch....）（一）

VMware Workstation Pro 17虚拟机超级详细搭建（含redis，nacos，docker, rabbitmq，sentinel，elasticsearch....）（一）

今天从零搭建一下虚拟机的环境&#xff0c;把nacos&#xff0c;redis等微服务组件还有数据库搭建到里面&#xff0c;首先看到的是我们最开始下载VMware Workstation Pro 17 之后的样子&#xff0c;总共一起应该有三部分因为篇幅太长了 下载地址 : VMware - Delivering a Digit…
阅读更多...
echarts睡眠分期

echarts睡眠分期

效果 echarts核心配置 option {tooltip: {trigger: axis // 触发方式为axis&#xff0c;表示数据项图形触发&#xff0c;此时坐标轴上的刻度也会显示提示信息。},xAxis: {show: false,type: category,data: [2024-02-02 12:00:01,2024-02-02 12:00:02,2024-02-02 12:00:03,20…
阅读更多...
stm32启动文件里面的__main和主函数main()

stm32启动文件里面的__main和主函数main()

一、__main和main()之间的关系 先来对stm32启动过程简单学习 启动文件里面的Reset_Handler&#xff1a; 调用过程&#xff1a; stm32在启动后先进入重启中断函数Reset_Handler&#xff0c;其中会先后调用SystemInit和__main函数&#xff0c; __main函数属于c库函数&…
阅读更多...
3GPP 协议资料学习和文档下载

3GPP 协议资料学习和文档下载

一、登录3GPP官网 3GPP – The Mobile Broadband Standard 二、选择Specifications Per TSG Round 三、选择ftp下载路径 四、选择不同阶段的3GPP协议 包含了从1999年到R18,甚至更新到当前最新的协议。 五、查看对应版本的LTE或者5G NR协议 其中LTE射频相关章节为36.521系列&…
阅读更多...
【黄啊码】使用cloudflare搭建OpenAI的接口

【黄啊码】使用cloudflare搭建OpenAI的接口

现在&#xff0c;我们可以使用cloudflare自己搭建一个OpenAI代理服务&#xff0c;使用我们自己的转发代理 第一步&#xff1a;注册cloudflare账号 前往官方网站注册一个账户 第二步&#xff1a;创建worker&#xff0c;进行请求中转 名字可以自己随便取一个&#xff0c;点击快…
阅读更多...
leetcode 2671

leetcode 2671

leetcode 2671 题目 例子 思路1 使用哈希&#xff0c; unordered_map 是基于hash 实现的key,val 存储。 代码1 class FrequencyTracker {unordered_map<int, int>m;public:FrequencyTracker() { }void add(int number) {if(m.find(number) m.end()){m.insert({num…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023