• ＜unordered_set、unordered_map的模拟实现＞——《C++高阶》

    目录

     1.unordered_set、unordered_map的结构分析:

    1.1 哈希表的改造

    1.2 unordered_map模型分析：

    2.unordered_set、unordered_map模拟实现：

    2.1 unordered_set模拟实现:

    2.2 unordered_map模拟实现:

    2.3 附用的模拟实现的开散列哈希表

    后记：●由于作者水平有限，文章难免存在谬误之处，敬请读者斧正，俚语成篇，恳望指教！

                                                                               ——By 作者：新晓·故知

     1.unordered_set、unordered_map的结构分析:

    1.1 哈希表的改造

    1. 模板参数列表的改造 
    1. // K:关键码类型
    2. // V: 不同容器V的类型不同，如果是unordered_map，V代表一个键值对，如果是
    3. unordered_set,V 为 K
    4. // KeyOfValue: 因为V的类型不同，通过value取key的方式就不同，详细见
    5. unordered_map/set的实现
    6. // HF: 哈希函数仿函数对象类型，哈希函数使用除留余数法，需要将Key转换为整形数字才能
    7. 取模
    8. template<class K, class V, class KeyOfValue, class HF = DefHashF >
    9. class HashBucket;
    2. 增加迭代器操作 
    1. // 为了实现简单，在哈希桶的迭代器类中需要用到hashBucket本身，
    2. template<class K, class V, class KeyOfValue, class HF>
    3. class HashBucket;
    4. // 注意：因为哈希桶在底层是单链表结构，所以哈希桶的迭代器不需要--操作
    5. template <class K, class V, class KeyOfValue, class HF>
    6. struct HBIterator
    7. {
    8.  typedef HashBucket HashBucket;
    9.  typedef HashBucketNode* PNode;
    10.  typedef HBIterator Self;
    11.  HBIterator(PNode pNode = nullptr, HashBucket* pHt = nullptr);
    12.  Self& operator++()
    13.  {
    14.          // 当前迭代器所指节点后还有节点时直接取其下一个节点
    15.  if (_pNode->_pNext)
    16.  _pNode = _pNode->_pNext;
    17.  else
    18.  {
    19.  // 找下一个不空的桶，返回该桶中第一个节点
    20.  size_t bucketNo = _pHt->HashFunc(KeyOfValue()(_pNode- >_data))+1;
    21.  for (; bucketNo < _pHt->BucketCount(); ++bucketNo)
    22.  {
    23.  if (_pNode = _pHt->_ht[bucketNo])
    24.  break;
    25.  }
    26.  }return *this;
    27.  }
    28.  Self operator++(int);
    29.     V& operator*();
    30.  V* operator->();
    31.  bool operator==(const Self& it) const;
    32.  bool operator!=(const Self& it) const;
    33.  PNode _pNode;             // 当前迭代器关联的节点
    34.  HashBucket* _pHt;         // 哈希桶--主要是为了找下一个空桶时候方便
    35. };
    3. 增加通过key获取value操作 
    1. template<class K, class V, class KeyOfValue, class HF = DefHashF >
    2. class HashBucket
    3. {
    4.  friend HBIterator;
    5.     // ......
    6. public:
    7.  typedef HBIterator Iterator;
    8.  //
    9.     // ...
    10.  // 迭代器
    11.  Iterator Begin()
    12.  {
    13.  size_t bucketNo = 0;
    14.  for (; bucketNo < _ht.capacity(); ++bucketNo)
    15.  {
    16.  if (_ht[bucketNo])
    17.  break;
    18.  }
    19.  if (bucketNo < _ht.capacity())
    20.  return Iterator(_ht[bucketNo], this);
    21.  else
    22.  return Iterator(nullptr, this);
    23.  }
    24.  Iterator End(){ return Iterator(nullptr, this);}
    25.     Iterator Find(const K& key);
    26.  Iterator Insert(const V& data);
    27.  Iterator Erase(const K& key);
    28.     
    29.     // 为key的元素在桶中的个数
    30.  size_t Count(const K& key)
    31.  {
    32.  if(Find(key) != End())
    33.             return 1;
    34.         
    35.         return 0;
    36.  }
    37.     
    38.     size_t BucketCount()const{ return _ht.capacity();}
    39.     size_t BucketSize(size_t bucketNo)
    40.    {
    41.         size_t count = 0;
    42.    PNode pCur = _ht[bucketNo];
    43.         while(pCur)
    44.        {
    45.             count++;
    46.             pCur = pCur->_pNext;
    47.        }
    48.         
    49.         return count;
    50.    }
    51.     
    52.     // ......
    53. };

    1.2 unordered_map模型分析：

    1. // unordered_map中存储的是pair的键值对，K为key的类型，V为value的类型，HF哈希
    2. 函数类型
    3. // unordered_map在实现时，只需将hashbucket中的接口重新封装即可
    4. template<class K, class V, class HF = DefHashF>
    5. class unordered_map
    6. {
    7.  typedef pair ValueType;
    8. typedef HashBucket HT;
    9. // 通过key获取value的操作
    10.  struct KeyOfValue
    11.  {
    12.  const K& operator()(const ValueType& data)
    13.  { return data.first;}
    14.  };
    15. public:
    16.  typename typedef HT::Iterator iterator;
    17. public:
    18.  unordered_map(): _ht()
    19.  {}
    20.  
    21.  iterator begin(){ return _ht.Begin();}
    22.  iterator end(){ return _ht.End();}
    23.  
    24.  // capacity
    25.  size_t size()const{ return _ht.Size();}
    26.  bool empty()const{return _ht.Empty();}
    27.  ///
    28.  // Acess
    29.  V& operator[](const K& key)
    30.  {
    31.  return (*(_ht.InsertUnique(ValueType(key, V())).first)).second;
    32.  }
    33.  const V& operator[](const K& key)const;
    34.  //
    35.  // lookup
    36.  iterator find(const K& key){ return _ht.Find(key);}
    37.  size_t count(const K& key){ return _ht.Count(key);}
    38.  /
    39.  // modify
    40.  pairbool> insert(const ValueType& valye)
    41.  { return _ht.Insert(valye);}
    42.  iterator erase(iterator position)
    43.  { return _ht.Erase(position);}
    44.  
    45.  // bucket
    46.  size_t bucket_count(){ return _ht.BucketCount();}
    47.  size_t bucket_size(const K& key){ return _ht.BucketSize(key);}
    48. private:
    49.  HT _ht;
    50. };

    2.unordered_set、unordered_map模拟实现：

    2.1 unordered_set模拟实现:

    1. #include"OpenHT.h"
    2.  
    3. namespace my
    4. {
    5. 	template<class K, class HashFunc = DefaultHash>
    6. 	class unordered_set
    7. 	{
    8. 		//内部类
    9. 		struct SetKeyOfT
    10. 		{
    11. 			const K& operator()(const K& key)
    12. 			{
    13. 				return key;
    14. 			}
    15. 		};
    16. 	public:
    17. 		typedef typename Bucket::HashTable::iterator iterator;
    18.  
    19. 		iterator begin()
    20. 		{
    21. 			return _ht.begin();
    22. 		}
    23.  
    24. 		iterator end()
    25. 		{
    26. 			return _ht.end();
    27. 		}
    28. 		//bool insert(const K& key)
    29. 		pairbool> insert(const K& key)
    30. 		{
    31. 			return _ht.Insert(key);
    32. 		}
    33. 		iterator find(const K& key)
    34. 		{
    35. 			return _ht.Find(key);
    36. 		}
    37. 		bool erase(const K& key)
    38. 		{
    39. 			return _ht.Erase(key);
    40. 		}
    41. 	private:
    42. 		Bucket::HashTable _ht;
    43. 	};
    44. 	
    45. }

     2.2 unordered_map模拟实现:

     

    1. #include"OpenHT.h"
    2.  
    3. namespace my
    4. {
    5. 	template<class K, class V, class HashFunc = DefaultHash>
    6. 	class unordered_map
    7. 	{
    8. 		//内部类
    9. 		struct MapKeyOfT
    10. 		{
    11. 			const K& operator()(const pair& kv)
    12. 			{
    13. 				return kv.first;
    14. 			}
    15. 		};
    16. 	public:
    17. 		//定义map的迭代器
    18. 		typedef typename Bucket::HashTable, MapKeyOfT, HashFunc> ::iterator iterator;
    19. 		iterator begin()
    20. 		{
    21. 			return _ht.begin();
    22. 		}
    23.  
    24. 		iterator end()
    25. 		{
    26. 			return _ht.end();
    27. 		}
    28. 		//bool insert(const pair& kv)
    29. 		pairbool> insert(const pair& kv)
    30. 		{
    31. 			return _ht.Insert(kv);
    32.  
    33. 		}
    34. 		iterator find(const K& key)
    35. 		{
    36. 			return _ht.Find(key);
    37. 		}
    38. 		bool erase(const K& key)
    39. 		{
    40. 			return _ht.Erase(key);
    41. 		}
    42. 		V& operator[](const K& key)
    43. 		{
    44. 			//pair ret = insert(make_pair(key, V()));
    45. 			auto ret = insert(make_pair(key, V()));
    46. 			return ret.first->second;  //first是迭代器，而map里面访问second要用->,其实这里有两个->,但为了可读性
    47. 		}
    48. 	private:
    49. 		Bucket::HashTable, MapKeyOfT,HashFunc> _ht;
    50. 	};
    51. }

    2.3 附用的模拟实现的开散列哈希表

    OpenHT.h:

    1. #pragma once
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8. #include
    9. using namespace std;
    10.  
    11. //仿函数
    12. template<class K>
    13. struct DefaultHash        //1.普通类直接强转
    14. {
    15. 	size_t operator()(const K& key)
    16. 	{
    17. 		return(size_t)key; //支持取模，强转为整数
    18. 	}
    19. };
    20. template<>
    21. struct DefaultHash     //String类特化
    22. {
    23. 	size_t operator()(const string& key)
    24. 	{
    25. 		//4.BKDR法
    26. 		size_t hash = 0;
    27. 		for (auto ch : key)
    28. 		{
    29. 			hash = hash * 131 + ch;
    30. 		}
    31. 		return hash;
    32. 	}
    33. };
    34. namespace Bucket
    35. {
    36. 	template<class T>
    37. 	struct HashNode
    38. 	{
    39. 		T _data;
    40. 		HashNode* _next;
    41. 		HashNode(const T& data)
    42. 			:_data(data)
    43. 			, _next(nullptr)
    44. 		{}
    45. 	};
    46.  
    47. 	template<class K, class T, class KeyOfT, class HashFunc>
    48. 	class HashTable;
    49.  
    50. 	template<class K, class T, class KeyOfT, class HashFunc>
    51. 	class __HTIterator   //单向迭代器
    52. 	{
    53. 		typedef HashNode Node;
    54. 		typedef __HTIterator Self;
    55. 	public:
    56. 		Node* _node;
    57. 		HashTable* _pht;
    58. 		__HTIterator(){}   //默认哈希迭代器构造函数
    59. 		__HTIterator(Node* node, HashTable* pht)
    60. 			:_node(node)
    61. 			,_pht(pht)
    62. 		{}
    63.  
    64. 		Self& operator++()
    65. 		{
    66. 			if (_node->_next)
    67. 			{
    68. 				_node = _node->_next;
    69. 			}
    70. 			else
    71. 			{
    72. 				KeyOfT kot;
    73. 				HashFunc hf;
    74. 				size_t hashi = hf(kot(_node->_data))%_pht->_tables.size();
    75. 				++hashi;
    76. 				//找下一个不为空的桶
    77. 				for (; hashi < _pht->_tables.size(); ++hashi)
    78. 				{
    79. 					if (_pht->_tables[hashi])
    80. 					{
    81. 						_node = _pht->_tables[hashi];
    82. 						break;
    83. 					}
    84. 				}
    85.  
    86. 				// 没有找到不为空的桶，用nullptr去做end标识
    87. 				if (hashi == _pht->_tables.size())
    88. 				{
    89. 					_node = nullptr;
    90. 				}
    91. 			}
    92.  
    93. 			return *this;
    94. 		}
    95.  
    96. 		T& operator*()
    97. 		{
    98. 			return _node->_data;
    99. 		}
    100.  
    101. 		T* operator->()
    102. 		{
    103. 			return &_node->_data;
    104. 		}
    105.  
    106. 		bool operator!=(const Self& s) const
    107. 		{
    108. 			return _node != s._node;
    109. 		}
    110.  
    111. 		bool operator==(const Self& s) const
    112. 		{
    113. 			return _node == s._node;
    114. 		}
    115. 	};
    116.  
    117. 	//unordered_set--->HashTable _ht;
    118. 	//unordered_map--->HashTable, MapKeyOfT> _ht;
    119. 	template<class K, class T, class KeyOfT, class HashFunc>
    120. 	class HashTable
    121. 	{
    122. 		template<class K, class T, class KeyOfT, class HashFunc>
    123. 		friend class __HTIterator;
    124. 		typedef HashNode Node;
    125. 	public:
    126. 		typedef __HTIterator iterator;
    127. 		iterator begin()
    128. 		{
    129. 			for (size_t i = 0; i < _tables.size(); ++i)
    130. 			{
    131. 				Node* cur = _tables[i];
    132. 				if (cur)
    133. 				{
    134. 					return iterator(cur, this);
    135. 				}
    136. 			}
    137.  
    138. 			return end();
    139. 		}
    140.  
    141. 		iterator end()
    142. 		{
    143. 			return iterator(nullptr, this);
    144. 		}
    145. 		//手动实现Node的析构函数
    146. 		~HashTable()
    147. 		{
    148. 			for (size_t i = 0; i < _tables.size(); ++i)
    149. 			{
    150. 				Node* cur = _tables[i];
    151. 				while (cur)
    152. 				{
    153. 					Node* next = cur->_next;
    154. 					delete cur;
    155. 					cur = next;
    156. 				}
    157. 				_tables[i] = nullptr;
    158. 			}
    159. 		}
    160. 		
    161. 		///
    162. 		HashTable() = default;  //强制生成默认构造函数
    163.  
    164. 		链表桶的深拷贝
    165. 		//HashTable(const HashTable ht)
    166. 		//{
    167. 		//	int sz = ht._tables.size();
    168. 		//	for (int i = 0; i < sz; i++)
    169. 		//	{
    170. 		//		Node* cur = ht._tables[i];
    171. 		//		while (cur)
    172. 		//		{
    173. 		//			this->Insert(cur->_kv);
    174. 		//			cur = cur->_next;
    175. 		//		}
    176. 		//	}
    177. 		//	_n = ht._n;
    178.  
    179. 		//}
    180. 		链表桶的赋值重载
    181. 		//HashTable& operator=(HashTable ht)
    182. 		//{
    183. 		//	//现代写法
    184. 		//	ht._tablle.swap(_tables);
    185. 		//	_n = ht._n;
    186. 		//}
    187. 		///
    188. 		size_t GetNextPrime(size_t prime)
    189. 		{
    190. 			const int PRIMECOUNT = 28;
    191. 			static const size_t primeList[PRIMECOUNT] =
    192. 			{
    193. 				53ul, 97ul, 193ul, 389ul, 769ul,
    194. 				1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
    195. 				49157ul, 98317ul, 196613ul, 393241ul, 786433ul,
    196. 				1572869ul, 3145739ul, 6291469ul, 12582917ul, 25165843ul,
    197. 				50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul,
    198. 				1610612741ul, 3221225473ul, 4294967291ul
    199. 			};
    200.  
    201. 			// 获取比prime大那一个素数
    202. 			size_t i = 0;
    203. 			for (; i < PRIMECOUNT; ++i)
    204. 			{
    205. 				if (primeList[i] > prime)
    206. 					return primeList[i];
    207. 			}
    208.  
    209. 			return primeList[i];
    210. 		}
    211. 		//bool Insert(const T& data)
    212. 		pairbool> Insert(const T& data)
    213. 		{
    214. 			HashFunc hf;
    215. 			KeyOfT kot;
    216. 			//if (Find(kot(data)))  //使用仿函数，不知道data是set还是map
    217. 			//if (Find(kot(data))!=end())  //使用仿函数，不知道data是set还是map
    218.  
    219. 			iterator pos = Find(kot(data));
    220. 			if(pos!=end())
    221. 			{
    222. 				//return false;
    223. 				return make_pair(pos,false);
    224. 			}
    225.  
    226. 			//负载因子（这里设置为1）  扩容
    227. 			if (_tables.size() == _n)
    228. 			{
    229. 				//写法2：扩容
    230. 				//size_t newSize = _tables.size() == 0 ? 10 : _tables.size() * 2;
    231. 				//写法3：
    232. 				size_t newSize = GetNextPrime(_tables.size());
    233. 				if (newSize != _tables.size())
    234. 				{
    235. 					vector newTable;
    236. 					newTable.resize(newSize, nullptr);
    237.  
    238. 					for (size_t i = 0; i < _tables.size(); ++i)
    239. 					{
    240. 						Node* cur = _tables[i];
    241. 						while (cur)
    242. 						{
    243. 							size_t hashi = hf(kot(cur->_data)) % newSize;  //hf转换为整型,kot()取k
    244. 							cur->_next = newTable[hashi];
    245. 							newTable[hashi] = cur;
    246. 							cur = cur->_next;
    247. 						}
    248. 						_tables[i] = nullptr;
    249. 					}
    250. 					newTable.swap(_tables);
    251.  
    252. 				}
    253. 			}
    254. 			size_t hashi = hf(kot(data)); //两层仿函数调用
    255. 			hashi %= _tables.size();
    256. 			//头插到对应的桶即可
    257. 			Node* newnode = new Node(data);
    258. 			newnode->_next = _tables[hashi];
    259. 			_tables[hashi] = newnode;
    260. 			++_n;
    261. 			//return true;
    262. 			return make_pair(iterator(newnode,this),false);
    263. 		}
    264. 		//Node* Find(const K& key)
    265. 		iterator Find(const K& key)
    266. 		{
    267. 			if (_tables.size() == 0)
    268. 			{
    269. 				//return nullptr;
    270. 				return iterator(nullptr,this);
    271.  
    272. 			}
    273. 			
    274. 			KeyOfT kot;
    275. 			//写法1：有名对象
    276. 			HashFunc hf;
    277. 			size_t hashi = hf(key);
    278.  
    279. 			//写法2：匿名对象
    280. 			//size_t hashi = HashFunc()(key);
    281.  
    282. 			hashi %= _tables.size();
    283. 			Node* cur = _tables[hashi];
    284. 			while (cur)
    285. 			{
    286. 				if (kot(cur->_data) == key)
    287. 				{
    288. 					//return cur;
    289. 					return iterator(cur, this);
    290. 				}
    291. 				cur = cur->_next;
    292. 			}
    293. 			//return nullptr;  //效率高，是因为直接返回了指针
    294. 			return iterator(nullptr, this);
    295. 		}
    296. 		bool Erase(const K& key)
    297. 		{
    298. 			if (_tables.size() == 0)
    299. 			{
    300. 				return false;
    301. 			}
    302. 			KeyOfT kot;
    303.  
    304. 			//写法1：有名对象
    305. 			HashFunc hf;
    306. 			size_t hashi = hf(key);
    307. 			hashi %= _tables.size();
    308. 			Node* cur = _tables[hashi];
    309. 			Node* prev = nullptr;
    310. 			while (cur)
    311. 			{
    312. 				if (kot(cur->_data) == key)
    313. 				{
    314. 					if (prev == nullptr)
    315. 					{
    316. 						_tables[hashi] = cur->_next;
    317. 					}
    318. 					else
    319. 					{
    320. 						prev->_next = cur->_next;
    321. 					}
    322. 					delete cur;
    323. 					return true;
    324. 					
    325. 				}
    326. 				cur = cur->_next;
    327. 			}
    328. 			return false;
    329. 		}
    330. 	private:
    331. 		//指针数组
    332. 		//没有使用list，是因为list是双向链表，成本大 vector> _tables; 但不用手动写析构函数
    333. 		vector _tables;    
    334. 		//开散列采用挂起，如果新表扩容，那么当旧表释放，vector会将自己的释放，
    335. 		//但是挂在vector的结点Node* 不会自动释放，因为Node* 是内置类型，需要手动释放。
    336. 		size_t _n = 0;
    337. 	};
    338. }

    Test.cpp: 

    1. #include"OpenHT.h"
    2. #include"UnorderedSet.h"
    3. #include"UnorderedMap.h"
    4.  
    5. //
    6. //1.库中的UnorderedSet、UnorderedMap测试
    7. void test_std_UnorderedSet()
    8. {
    9. 	std::unordered_set<int> s;
    10. 	s.insert(9);
    11. 	s.insert(7);
    12. 	s.insert(2);
    13. 	s.insert(1);
    14. 	s.insert(6);
    15. 	s.insert(5);
    16. 	//1.迭代器遍历
    17. 	//unordered_set::iterator it = s.begin();
    18. 	//auto it = s.begin();
    19. 	//写法2：
    20. 	std::unordered_set<int>::iterator it;
    21. 	it = s.begin();
    22. 	while (it != s.end())
    23. 	{
    24. 		cout << *it << " ";
    25. 		++it;
    26. 	}
    27. 	cout << endl;
    28. 	//2.范围for遍历
    29. 	for (auto e : s)
    30. 	{
    31. 		cout << e << " ";
    32. 	}
    33. 	cout << endl;
    34. }
    35. void test_std_UnorderedMap()
    36. {
    37. 	std::unordered_map dict;
    38. 	dict.insert(make_pair("sort", "排序"));
    39. 	dict.insert(make_pair("left", "左边"));
    40. 	dict.insert(make_pair("left", "剩余"));
    41. 	dict["string"];
    42. 	dict["left"] = "剩余";
    43. 	dict["string"] = "字符串";
    44. 	//迭代器遍历
    45. 	//std::unordered_map::iterator it = dict.begin();
    46. 	auto it = dict.begin();
    47. 	while (it != dict.end())
    48. 	{
    49. 		cout << it->first << " " << it->second << endl;
    50. 		++it;
    51. 	}
    52. 	cout << endl;
    53. 	//范围for遍历
    54. 	for (auto& kv : dict)
    55. 	{
    56. 		cout << kv.first << " " << kv.second << endl;
    57. 	}
    58. }
    59. //
    60. //2.模拟实现UnorderedSet、UnorderedMap测试
    61. void test_my_UnorderedSet()
    62. {
    63. 	my::unordered_set<int> s;
    64. 	s.insert(9);
    65. 	s.insert(7);
    66. 	s.insert(2);
    67. 	s.insert(1);
    68. 	s.insert(6);
    69. 	s.insert(5);
    70. 	//1.迭代器遍历
    71. 	//my::unordered_set::iterator it = s.begin();
    72. 	//auto it = s.begin();
    73. 	//写法2：
    74. 	my::unordered_set<int>::iterator it;
    75. 	it = s.begin();
    76. 	while (it != s.end())
    77. 	{
    78. 		cout << *it << " ";
    79. 		++it;
    80. 	}
    81. 	cout << endl;
    82. 	//2.范围for遍历
    83. 	for (auto e : s)
    84. 	{
    85. 		cout << e << " ";
    86. 	}
    87. 	cout << endl;
    88. }
    89. void test_my_UnorderedMap()
    90. {
    91. 	my::unordered_map dict;
    92. 	dict.insert(make_pair("sort", "排序"));
    93. 	dict.insert(make_pair("left", "左边"));
    94. 	dict.insert(make_pair("left", "剩余"));
    95. 	dict["string"];
    96. 	dict["left"] = "剩余";
    97. 	dict["string"] = "字符串";
    98. 	//迭代器遍历
    99. 	//my::unordered_map::iterator it = dict.begin();
    100. 	auto it = dict.begin();
    101. 	while (it != dict.end())
    102. 	{
    103. 		cout << it->first << " " << it->second << endl;
    104. 		++it;
    105. 	}
    106. 	cout << endl;
    107. 	//范围for遍历
    108. 	for (auto& kv : dict)
    109. 	{
    110. 		cout << kv.first << " " << kv.second << endl;
    111. 	}
    112. }
    113. int main()
    114. {
    115. 	//test_std_UnorderedSet();
    116. 	//test_std_UnorderedMap();
    117.  
    118. 	//test_my_UnorderedSet();
    119. 	test_my_UnorderedMap();
    120.  
    121. 	return 0;
    122. }

     

    测试示例：

     

     

     

     

    后记：
    ●由于作者水平有限，文章难免存在谬误之处，敬请读者斧正，俚语成篇，恳望指教！

                                                                               ——By 作者：新晓·故知

     

  • 相关阅读:
    CentOS 7.3 Linux系统安装过程介绍
    MarkText快捷键（随时补充中）
    PromQL 查询监控数据
    行为型：发布订阅模式
    RHCSA 05 - 管理Selinux
    Science子刊 | 将CAR-T细胞疗法与造血干细胞移植相结合 或许 能治疗所有血液癌症...
    【 OpenGauss源码学习 —— （hash_search）】
    solidworks导入stl保持为曲面且可编译的注意项
    Java基础教程详解：多线程(1)-----多线程概念
    nprogress进度条的安装与使用
  • 原文地址：https://blog.csdn.net/m0_57859086/article/details/126861898