【C++】unordered_set和unordered_map

已于 2024-04-16 19:28:37 修改
阅读量198 收藏 3
点赞数 7
分类专栏： C++ 文章标签： c++ 哈希算法
于 2024-04-16 19:23:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FZC206/article/details/137771893
版权

底层哈希结构

namespace hash_bucket
{
	template<class T>
	struct HashData
	{
		T _data;
		struct HashData* next = nullptr;
		HashData(const T& data)
			:_data(data)
		{}
	};

	//仿函数:这里直接用开散列仿函数
	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 res = 0;
			for (auto e : key)
			{
				res *= 131;
				res += e;
			}
			return res;
		}
	};

	//迭代器
	//前置声明
	template<class K, class T, class Hash, class KeyOfT>
	class HashTable;

	template<class K, class T, class Hash, class KeyOfT>
	struct _HashTableIterator
	{
		typedef HashData<T> Node;
		typedef HashTable<K, T, Hash, KeyOfT> Ht;
		typedef _HashTableIterator<K, T, Hash, KeyOfT> Self;

		Node* _node;
		Ht* _pht;

		_HashTableIterator(Node* node,Ht* 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 hash;
				size_t i = hash(kot(_node->_data)) % _pht->_size;
				for (++i; i < _pht->_tables.size(); i++)
				{
					if (_pht->_tables[i])
					{
						_node = _pht->_tables[i];
						if(node)
							break;
					}
				}
				if (i == _pht->_tables.size())
				{
					_node = nullptr;
				}
			}
			return *this;
		}
		bool operator!=(Self& s)const
		{
			return s._node != _node;
		}
		bool operator==(Self& s)const
		{
			return !operator!=(s);
		}
	};

	template<class K, class T, class Hash, class KeyOfT>
	class HashTable
	{
		typedef HashData<T> Node;
		typedef _HashTableIterator<K, T, Hash, KeyOfT> iterator;
	public:
		iterator begin()
		{
			for (size_t i = 0; i < _tables.size(); i++)
			{
				if (_tables[i] != nullptr)
					return iterator(_tables[i], this);
			}
			return end();
		}
		iterator end()
		{
			return iterator(nullptr, this);
		}
	public:
		HashTable()
			:_size(0)
			,_tables(10, nullptr)
		{}
		~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)
		{
			Hash hash;
			KeyOfT kot;

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

			//负载因子到 1 就扩容
			if (_size == _tables.size())//扩容
			{
				size_t newSize = _tables.size() * 2;
				vector<Node*> newTables(newSize, nullptr);
				size_t hashi = 0;
				for (size_t i = 0; i < _tables.size(); i++)
				{
					Node* cur = _tables[i];
					while (cur)
					{
						Node* next = cur->next;
						hashi = hash(kot(cur->_data)) % newTables.size();
						cur->next = newTables[hashi];
						newTables[hashi] = cur;
						cur = next;
					}
					_tables[i] = nullptr;
				}
				_tables.swap(newTables);
			}

			size_t hashi = hash(kot(data)) % _tables.size();
			//头插
			Node* old = _tables[hashi];
			_tables[hashi] = new Node(data);
			_tables[hashi]->next = old;
			_size++;
			return true;
		}
		Node* Find(const K& key)
		{
			if (_size == 0)
				return nullptr;

			Hash hash;
			KeyOfT kot;
			size_t hashi = hash(key) % _tables.size();
			Node* cur = nullptr;
			for (size_t i = 0; i < _tables.size(); i++)
			{
				cur = _tables[i];
				while (cur)
				{
					if (kot(cur->_data) == key)
					{
						return cur;
					}
					cur = cur->next;
				}
			}
			return nullptr;
		}
		void Print()
		{
			KeyOfT kot;
			for (size_t i = 0; i < _tables.size(); i++)
			{
				Node* cur = _tables[i];
				while (cur)
				{
					cout << "[" << kot(cur->_data) << ": " << kot(cur->_data) << "]-->";
					cur = cur->next;
				}
			}
			cout << endl;
		}
		bool Erase(const K& key)
		{
			Hash hash;
			KeyOfT kot;
			size_t hashi = hash(key) % _tables.size();
			Node* cur = _tables[hashi];
			Node* prev = nullptr;
			while (cur)
			{
				if (kot(cur->_data) == key)
				{
					if (prev)
					{
						prev->next = cur->next;
					}
					else
					{
						_tables[hashi] = cur->next;

					}
					delete cur;
					cur = nullptr;
					return true;
				}
				else
				{
					prev = cur;
					cur = cur->next;
				}
			}
			return false;
		}
		size_t size()
		{
			return _size;
		}
	private:
		size_t _size = 0;//有效数据个数
		vector<Node*> _tables;
	};
}

unordered_set

namespace hash_bucket
{
	template<class K, class Hash = HashFunc<K>>
	class unordered_set
	{
		struct SetKeyOfT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	private:
		HashTable<K, K,Hash,SetKeyOfT> _ht;
	public:
		typedef  typename HashTable<K, K, Hash, SetKeyOfT> ::iterator iterator;
		iterator begin()
		{
			return _ht.begin();
		}
		iterator end()
		{
			return _ht.end();
		}
		bool insert(const K& Node)
		{
			return _ht.Insert(Node);
		}
	};
	void unorderedset_test1()
	{
		unordered_set<int> s;

		s.insert(2);
		s.insert(4);
		s.insert(9);
		s.insert(1);
		s.insert(2);
		s.insert(3);

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

unordered_map

namespace hash_bucket
{
	template<class K,class V, class Hash = HashFunc<K>>
	class unordered_map
	{
		struct MapKeyOfT
		{
			const K& operator()(const pair<K, V>& key)
			{
				return key.first;
			}
		};
	private:
		HashTable<K, pair<K, V>, Hash, MapKeyOfT> _ht;
	public:
		typedef  typename HashTable<K, pair<K, V>, Hash, MapKeyOfT>::iterator iterator;
		iterator begin()
		{
			return _ht.begin();
		}
		iterator end()
		{
			return _ht.end();
		}
		bool insert(const pair<K, V>& Node)
		{
			return _ht.Insert(Node);
		}
	};
	void unorderedmap_test1()
	{
		unordered_map<string, string> dict;
		dict.insert(make_pair("insert", "插入"));
		dict.insert(make_pair("sort" , "排序"));
		dict.insert(make_pair("delete", "删除"));
		dict.insert(make_pair("string", "字符串"));
		dict.insert(make_pair("iterator", "迭代器"));
		unordered_map<string, string>::iterator umit = dict.begin();
		//while (umit != dict.end())
		//{
		//	cout << umit->first << ":" << umit->second << endl;
		//	++umit;
		//}
		//cout << endl;
	}
}

此时编译：
在这里插入图片描述报错！
HashTable和其迭代器互相调用
从逻辑上讲，HashTable应该给迭代器开放权限，如下设置一个友元类即可
在这里插入图片描述
因为是模板故必须带参数。
经检测，以上代码有个小bug，可能会导致数据打印时无法跳出迭代器，形成死循环打印；
提示：错误点在该段代码中

		Self& operator++()
		{
			if (_node->next)
			{
				//当前桶
				_node = _node->next;
			}
			else
			{
				//下一个桶
				KeyOfT kot;
				Hash hash;
				size_t i = hash(kot(_node->_data)) % _pht->_size;
				for (++i; i < _pht->_tables.size(); i++)
				{
					if (_pht->_tables[i])
					{
						_node = _pht->_tables[i];
						if(node)
							break;
					}
				}
				if (i == _pht->_tables.size())
				{
					_node = nullptr;
				}
			}
			return *this;
		}

在这里插入图片描述
在这里我们是不是应该对哈希表的大小取模，而不是对现在的有效数据个数取模

size_t i = hash(kot(_node->_data)) % _pht->_tables.size();

完整代码

代码实现标准化，实现[ ]重载

#pragma once
#include "hash.h"
namespace hash_bucket
{
	template<class K, class Hash = HashFunc<K>>
	class unordered_set
	{
		struct SetKeyOfT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	private:
		HashTable<K, K,Hash,SetKeyOfT> _ht;
	public:
		typedef  typename HashTable<K, K, Hash, SetKeyOfT> ::iterator iterator;
		iterator begin()
		{
			return _ht.begin();
		}
		iterator end()
		{
			return _ht.end();
		}
		pair<iterator, bool> insert(const K& Node)
		{
			return _ht.Insert(Node);
		}
	};
	void unorderedset_test1()
	{
		unordered_set<int> s;

		s.insert(2);
		s.insert(4);
		s.insert(9);
		s.insert(1);
		s.insert(2);
		s.insert(3);

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

#pragma once
#include "hash.h"
namespace hash_bucket
{
	template<class K,class V, class Hash = HashFunc<K>>
	class unordered_map
	{
		struct MapKeyOfT
		{
			const K& operator()(const pair<K, V>& key)
			{
				return key.first;
			}
		};
	private:
		HashTable<K, pair<K, V>, Hash, MapKeyOfT> _ht;
	public:
		typedef  typename HashTable<K, pair<K, V>, Hash, MapKeyOfT>::iterator iterator;
		iterator begin()
		{
			return _ht.begin();
		}
		iterator end()
		{
			return _ht.end();
		}
		pair<iterator,bool> insert(const pair<K, V>& Node)
		{
			return _ht.Insert(Node);
		}
		V& operator[](const K& key)
		{
			pair<iterator, bool> ret = insert(make_pair(key, V()));
			return ret.first->second;
		}
	};
	void unorderedmap_test1()
	{
		unordered_map<string, string> dict;
		dict.insert(make_pair("insert", "插入"));
		dict.insert(make_pair("sort" , "排序"));
		dict.insert(make_pair("delete", "删除"));
		dict.insert(make_pair("string", "字符串"));
		dict.insert(make_pair("iterator", "迭代器"));
		unordered_map<string, string>::iterator umit = dict.begin();
		while (umit != dict.end())
		{
			cout << umit->first << ":" << umit->second << endl;
			++umit;
		}
		cout << endl;
	}
	void unorderedmap_test2()
	{
		string arr[] = { "梨子","苹果","猕猴桃","桃" ,"梨子","苹果", "猕猴桃","猕猴桃","猕猴桃","梨子","猕猴桃" };
		unordered_map<string, int> countMap;
		for (const auto& str : arr)
		{
			countMap[str]++;
		}
		unordered_map<string, int>::iterator it = countMap.begin();
		while (it != countMap.end())
		{
			cout << (*it).first << ":" << (*it).second << endl;
			++it;
		}
		cout << endl << endl;
		for (auto e : countMap)
		{
			cout << e.first << ":" << e.second << endl;
		}
		cout << endl;
	}
}

namespace hash_bucket
{
	template<class T>
	struct HashData
	{
		T _data;
		struct HashData* next = nullptr;
		HashData(const T& data)
			:_data(data)
		{}
	};

	//仿函数:这里直接用开散列仿函数
	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 res = 0;
			for (auto e : key)
			{
				res *= 131;
				res += e;
			}
			return res;
		}
	};

	//迭代器
	//前置声明
	template<class K, class T, class Hash, class KeyOfT>
	class HashTable;

	template<class K, class T, class Hash, class KeyOfT>
	struct _HashTableIterator
	{
		typedef HashData<T> Node;
		typedef HashTable<K, T, Hash, KeyOfT> Ht;
		typedef _HashTableIterator<K, T, Hash, KeyOfT> Self;

		Node* _node;
		Ht* _pht;

		_HashTableIterator(Node* node,Ht* 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 hash;
				size_t i = hash(kot(_node->_data)) % _pht->_tables.size();
				for (++i; i < _pht->_tables.size(); i++)
				{
					if (_pht->_tables[i])
					{
						_node = _pht->_tables[i];
						if (_node)
						{
							break;
						}
					}
				}
				if (i == _pht->_tables.size())
				{
					_node = nullptr;
				}
			}
			return *this;
		}
		Self& operator++(int)
		{
			Self tmp = this;
			if (_node->next)
			{
				//当前桶
				_node = _node->next;
			}
			else
			{
				//下一个桶
				KeyOfT kot;
				Hash hash;
				size_t i = hash(kot(_node->_data)) % _pht->size();
				for (++i; i < _pht->_tables.size(); i++)
				{
					if (_pht->_tables[i])
					{
						_node = _pht->_tables[i];
						break;
					}
				}
				if (i == _pht->_tables.size())
				{
					_node = nullptr;
				}
			}
			return tmp;
		}
		bool operator!=(const Self& s) const
		{
			return s._node != _node;
		}
		bool operator==(const Self& s) const
		{
			return s._node == _node;
		}
	};

	template<class K, class T, class Hash, class KeyOfT>
	class HashTable
	{
		template<class K, class T, class Hash, class KeyOfT>
		friend struct _HashTableIterator;
		typedef HashData<T> Node;
	public:
		typedef _HashTableIterator<K, T, Hash, KeyOfT> iterator;
		iterator begin()
		{
			for (size_t i = 0; i < _tables.size(); i++)
			{
				if (_tables[i] != nullptr)
					return iterator(_tables[i], this);
			}
			return end();
		}
		iterator end()
		{
			return iterator(nullptr, this);
		}
	public:
		HashTable()
			:_size(0)
			,_tables(10, nullptr)
		{}
		~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)
		{
			Hash hash;
			KeyOfT kot;

			iterator ret = Find(kot(data));
			if (ret != end())
				return make_pair(ret, false); 

			//负载因子到 1 就扩容
			if (_size == _tables.size())//扩容
			{
				size_t newSize = _tables.size() * 2;
				vector<Node*> newTables(newSize, nullptr);
				//这里为了减少调用，不像开散列那样采用复用insert的形式，而是直接将原表中的节点拿下来直接用
				//而且复用insert的时候会涉及空间的申请释放问题（申请新节点，将旧节点的值给新节点，然后释放新旧结点）
				size_t hashi = 0;
				//旧表数据移到新表
				//特别注意：一个一个数据移动，不可一串一串移动，那样的话会造成映射位置错误，最后使其数据不能被正常找到
				for (size_t i = 0; i < _tables.size(); i++)
				{
					Node* cur = _tables[i];
					while (cur)
					{
						Node* next = cur->next;
						hashi = hash(kot(cur->_data)) % newTables.size();
						cur->next = newTables[hashi];
						newTables[hashi] = cur;
						cur = next;
					}
					_tables[i] = nullptr;
				}
				_tables.swap(newTables);
			}

			size_t hashi = hash(kot(data)) % _tables.size();
			//头插
			Node* old = _tables[hashi];
			_tables[hashi] = new Node(data);
			_tables[hashi]->next = old;
			_size++;
			return make_pair(iterator(_tables[hashi], this), true);
		}
		iterator Find(const K& key)
		{
			if (_size == 0)
				return iterator(nullptr, this);

			Hash hash;
			KeyOfT kot;
			size_t hashi = hash(key) % _tables.size();
			Node* cur = nullptr;
			for (size_t i = 0; i < _tables.size(); i++)
			{
				cur = _tables[i];
				while (cur)
				{
					if (kot(cur->_data) == key)
					{
						return iterator(cur, this);
					}
					cur = cur->next;
				}
			}
			return end();
		}
		void Print()
		{
			KeyOfT kot;
			for (size_t i = 0; i < _tables.size(); i++)
			{
				Node* cur = _tables[i];
				while (cur)
				{
					cout << "[" << kot(cur->_data) << ": " << kot(cur->_data) << "]-->";
					cur = cur->next;
				}
			}
			cout << endl;
		}
		bool Erase(const K& key)
		{
			Hash hash;
			KeyOfT kot;
			size_t hashi = hash(key) % _tables.size();
			Node* cur = _tables[hashi];
			Node* prev = nullptr;
			while (cur)
			{
				if (kot(cur->_data) == key)
				{
					if (prev)
					{
						prev->next = cur->next;
					}
					else
					{
						_tables[hashi] = cur->next;

					}
					delete cur;
					cur = nullptr;
					return true;
				}
				else
				{
					prev = cur;
					cur = cur->next;
				}
			}
			return false;
		}
		size_t size()
		{
			return _size;
		}
	private:
		size_t _size = 0;//有效数据个数
		vector<Node*> _tables;
	};
}
风里画沙_0
关注
  • 7
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
robin-hood-hashing：基于C ++ 11141720的基于robin hood哈希的快速且内存高效的哈希表
01-30
robin_hood::unordered_map和robin_hood::unordered_set是std::unordered_map / std::unordered_set独立于平台的替代品，对于实际的用例而言，它既更快，更高效。 安装及使用 直接纳入 将添加到您的C ++项目。 ...
C++标准模板库指南_C++_
10-03
在`unordered_set`和`unordered_map`中，哈希函数用于计算元素的哈希值，以确定其在桶中的位置。哈希表提供了一种高效的方法来存储和查找元素，尤其是在元素数量大且元素分布均匀时。 理解并熟练使用C++ STL对于...
C++ unordered_set和unordered_map
sblbsgqxx的博客
03-24 834
不能随便的物理删除一个元素，不然会影响查找操作，比如现在有一个场景：你删除了一个元素，然后要查找的元素在你删除元素的后面，根据上面的查找规则，你是查不到这个元素的。怎么放进去的就怎么找出来，对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功。相信大家看了这个例子，可以体会到哈希的妙，但这出现了一个问题，两个元素映射到了同一个地方，这种情况叫。在往该结构中插入元素时，通过关键码和一个函数，计算出存放该元素的位置。：获取键值中查找元素的个数。
c++中 unordered_map 与 unordered_set 用法指南
人生只有一次，不妨大胆一点～～
06-01 1189
c++中 unordered_map 与 unordered_set 用法指南
C++ —— unordered_set、unordered_map的介绍及使用
weixin_66905164的博客
06-19 816
unordered_multimap容器与unordered_map容器的底层数据结构是一样的，都是哈希表，其次，它们所提供的成员函数的接口都是基本一致的，这里就不再列举了，这两种容器唯一的区别就是，unordered_multimap容器允许键值冗余，即unordered_multimap容器当中存储的键值对的key值是可以重复的。在内部，unordered_set中的元素没有按照任何特定的顺序排序，为了能在常数范围内找到指定的3.key，unordered_set将相同哈希值的键值放在相同的桶中。
【C++之unordered_set和unordered_map的介绍与应用】
m0_69455439的博客
07-01 723
C++学习笔记024 ---unordered_set和unordered_map的介绍与应用等知识
c++ map与unordered_map区别及使用
热门推荐
别说话写代码的博客
12-01 26万+
转自：https://blog.csdn.net/BillCYJ/article/details/78985895 需要引入的头文件不同 map: #include &lt; map &gt; unordered_map: #include &lt; unordered_map &gt; 内部实现机理不同 map： map内部实现了一个红黑树（红黑树是非严格平衡二叉搜索树，而AVL是严格平衡二...
C++ unordered_map和unordered_set的使用
qq_61635026的博客
09-16 2754
unordered_map在线文档说明unordered_map是存储键值对的关联式容器，其允许通过keys快速的索引到与其对应的value。在unordered_map中，键值通常用于惟一地标识元素，而映射值是一个对象，其内容与此键关联。键和映射值的类型可能不同。在内部,unordered_map没有对按照任何特定的顺序排序, 为了能在常数范围内找到key所对应的value，unordered_map将相同哈希值的键值对放在相同的桶中。
C++ unordered_map 和 unordered_set 常用函数
qq_40876059的博客
03-24 5024
unordered_map unordered_set
【C++】unordered_set和unordered_map介绍及使用【附OJ题】
m0_74044018的博客
10-08 518
c++中unordered_set与unordered_map的介绍及与set和map的对比，还有性能测试，最后讲解两道OJ题
【C++】unordered_set、unordered_map的介绍及使用
m0_70088010的博客
10-01 519
unordered_map是存储键值对的关联式容器，其允许通过keys快速的索引到与其对应的value。在unordered_map中，键值通常用于惟一地标识元素，而映射值是一个对象，其内容与此键关联。键和映射值的类型可能不同。在内部,unordered_map没有对按照任何特定的顺序排序, 为了能在常数范围内找到key所对应的value，unordered_map将相同哈希值的键值对放在相同的桶中。unordered_map容器。
【C++】unordered_set 和 unordered_map 使用 | 封装
qq_62939852的博客
05-27 2089
哈希桶HashBucket中需要将其内部的HashNode 的参数进行修改将原来的模板参数 K，V 改为 T同样由于不知道传入数据的是K还是K V类型的 ，所以 使用 T 类型的data代替之前实现的模板参数 K ，V分别代表 key 与value修改后 ， 第一个参数 拿到单独的K类型，是为了 使用 Find erase接口函数的参数为K第二个参数 T 决定了 拿到的是K类型 还是 K V 类型。
TongXunLu.rar_c++ 通讯录_数据结构_通讯录
09-20
其次，为了实现快速查找，可以采用哈希表（如std::unordered_map）来存储联系人。哈希表通过计算哈希值实现快速定位，平均时间复杂度为O(1)。每个联系人可以作为键，其详细信息作为值。这样，我们可以通过姓名快速...
STL.rar_c++ 容器使用
09-24
4. **映射容器(如Unordered_Set、Unordered_Map、Unordered_Multiset、Unordered_Multimap)**：这些容器使用哈希表实现，提供近乎常数时间的插入和查找操作，但元素的顺序不确定。 5. **栈(Stack)**：栈是一种后进...
STL-70个算法.rar_C++_stl 练习
09-23
STL提供了一些核心的数据结构，如vector（动态数组）、list（双向链表）、deque（双端队列）、set（红黑树实现的集合）、map（红黑树实现的键值对映射）和unordered_set/unordered_map（哈希表实现的集合和映射）。...
2024年C++面试题汇总及答案解析
最新发布
soaring_casia的专栏
07-25 347
唯一的指针，不允许其他指针与他共享指向的对象。比如指针指向的内存被释放了，但是指针没有置nullptr. 多个指针指向同一个内存，当free掉一个指针之后，其他指针就变成了野指针。C++这些年虽然难度大，但是热度仍然不减，在编程排行榜基本上都是前几位，得益于它良好的薪资待遇。SPI协议是一种采用主从模式的串行，全双工，同步通信总线，包括时钟，输入，输出，片选四个信号线，片选信号用于选择slave设备，输入输出的每个bit都需要和时钟沿同步。区别：指针指向一块儿内存，他的内容是所指内存的地址。
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1160
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
Delphi5实现鱼C屏幕保护程序
weixin_52116519的博客
07-24 326
使用Form1的events的oncreate事件，双击命名为FormCreate。即上面的“- □ ×”不显示。
C++中的模板函数和模板类
2302_81171591的博客
07-22 666
T1 ,classT2 ,... ,classTnclass类模板名//类内成员定义。
unordered_set和unordered_map的用法
03-15
unordered_set和unordered_map是C++标准库中的容器，用于存储和管理不重复的元素集合和键值对集合。 unordered_set是一个无序的集合容器，其中的元素是唯一的且无序的。它基于哈希表实现，因此插入、删除和查找操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值