C++进阶：哈希（1）

最新推荐文章于 2024-07-08 21:23:20 发布
最新推荐文章于 2024-07-08 21:23:20 发布
阅读量1k 收藏 9
点赞数 12
文章标签： c++ 哈希算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_71806743/article/details/138719468
版权

目录

1. 简介unordered_set与unordered_map

  1. 在C++库中，除开map与set这两个关联式容器外，还存在着另外两个此类容器，unordered_set，unordered_map。
  2. unordered中文释义为无序的，这也正是这一对容器使用时的表征特点，这一对容器分别对应set与map，即K模型与KV模型的存储数据结点。
  3. 那么，除开使用迭代器遍历时，其内存储数据无序外，这一对容器与map与set容器有何不同，为什么要在已有map与set的情况下，再向库中加入这一对乍看功能冗余且劣于原本map与set的容器呢？我们来看下面的一组对照试验。
  4. unordered_set与unordered_map其的关键性常用接口与使用和map，set相同，不同的是其只支持正向迭代器且多了一些桶，负载因子相关的接口。
#include <iostream>
using namespace std;
#include <unordered_set>
#include <set>
#include <stdlib.h>
#include <time.h>
#include <vector>

int main()
{
	const int N = 1000000;
	vector<int> data(N);
	set<int> s;
	unordered_set<int> us;
	srand((unsigned int)time(NULL));
	
	for (int i = 0; i < N; i++)
	{
		//data.push_back(rand());//重复数据多
		//data.push_back(rand() + i);//重复数据少
		data.push_back(i);//有序数据
	}

	//插入
	int begin1 = clock();
	for (auto e : data)
	{
		s.insert(e);
	}
	int end1 = clock();

	int begin2 = clock();
	for (auto e : data)
	{
		us.insert(e);
	}
	int end2 = clock();

	cout << "insert number：" << s.size() << endl << endl;

	//查找
	int begin3 = clock();
	for (auto e : data)
	{
		s.find(e);
	}
	int end3 = clock();

	int begin4 = clock();
	for (auto e : data)
	{
		us.find(e);
	}
	int end4 = clock();

	int begin5 = clock();
	for (auto e : data)
	{
		s.erase(e);
	}
	int end5 = clock();

	int begin6 = clock();
	for (auto e : data)
	{
		us.erase(e);
	}
	int end6 = clock();

	cout << "set Insert：" << end1 - begin1 << endl;
	cout << "unordered Insert：" << end2 - begin2 << endl << endl;

	cout << "set Find：" << end3 - begin3 << endl;
	cout << "unordered Find：" << end4 - begin4 << endl << endl;

	cout << "set Erase：" << end5 - begin5 << endl;
	cout << "unordered Erase：" << end6 - begin6 << endl << endl;
	
	return 0;
}

运行结果：
在这里插入图片描述

  1. 由运行结果可得
    <1> 当数据无序时在重复数据较多的情况下，unordered系列的容器，插入删除效率更高
    <2> 当数据无序但重复数据较少的情况下，两种类型的容器，两者插入数据效率仿佛
    <3> 当数据有序时，红黑树系列的容器插入效率更高
  2. 在日常的应用场景中，很少出现有序数据情况，虽然map，set有着遍历自得有序这一优势，但关联式容器的主要功能为映射关系与快速查询，其他优点尽是附带优势。所以，unordered系列容器的加入与学习是必要的。

2. 哈希表（散列）

2.1 哈希表的引入

  1. 在初阶数据结构的学习中，我们学习了一种排序方式，叫做基数排序，其使用数组下标表示需排序数据，下标对应的元素代表相应数据的出现次数。以此映射数据并排序，时间复杂度只有O(n)。
  2. 基数排序创建的数据存储数组，除可以用于数据排序外，我们不难发现其用来查询一个数据在或不再，可以通过访问下标对应数据直接得到，查询效率及其高。
  3. 这一为排序所创建的存储数组，就是一个简单的哈希表，我们也称之为散列，即数据并非连续而是散列在一段连续的空间中。
  4. 哈希表中的哈希，是指一种数据结构的设计思想，为通过某种映射关系为存储数据创建一个key值，其的映射关系不一，但都可以通过key值找到唯一对应的一个数据，且使得数据散列在存储空间中。
  5. 上述的存储结构为常见哈希表结构的一种，我们称之为直接定址法哈希表，但此种哈希表其使用上存在诸多限制，当存储数据的范围跨度较大时，就会使得空间浪费十分严重。接下来，我们来学习几种在其基础上进行优化具有实用价值的常用哈希表结构。

2.2 闭散列的除留余数法

2.2.1 前置知识补充与描述

  1. 除留余数法：为了解决存储数据大小范围跨度过大的问题，我们不再直接使用存储数据左key值映射，而是通过存储数据除以哈希表大小得到的余数做key值。这样就能将所有数据集中映射至一块指定大小的空间中。
  2. 哈希冲突/哈希碰撞：取余数做key值的方式虽然能够使得数据映射到一块指定空间中，并大幅度减少空间的浪费，可是这也会产生一个无法避免的问题，那就是不同数据的经过取余得到的余数可能相同，如此就会导致同一key值映射多个数据，使得无法进行需要的存储与查询。这一问题就被称为哈希碰撞。
  3. 线性探测与二次探测：哈希碰撞的解决存在多种方法策略，这里我们简单了解两种常用方式
    <1> 线性探测：当前key值对应数据位被占用时，向后遍历（hashi + i），直至找到为空的数据位再将数据存入，而探测查询时，也以线性逻辑搜索直至遍历至空，则代表查询数据不存在，越界回绕。
    <2> 二次探测：当前key指对数据位被占用时，当前key值依次加正整数的平方（hashi + i 2 i^2 i2）直至遍历至空存入，探测查询时，依次逻辑或至空结束，越界回绕。
  4. 补充：
    <1> 负载因子：哈希表中存储数据个数与哈希表长度的比值，一般控制在0.7左右，若负载因子超过，进行扩容
    <2> 线性探测容易导致数据的拥堵与踩踏，二次探测的方式为对此的优化
    <3> 处理非数字类型数据，将其转换为size_t类型后，再进行key值映射，采用仿函数的方式

在这里插入图片描述

2.2.2 闭散列哈希表实现

  1. 哈希表结构
//结点状态
enum State
{
	EMPTY,//可插入，查询结束
	EXIST,//不可插入，向后查询
	DELETE//可插入，向后查询
};

//数据结点
template<class K, class V>
struct HashNode
{
	pair<K, V> _kv;
	State _state;
	
	HashNode(const pair<K, V>& kv = make_pair(K(), V()))
		:_kv(kv)
		,_state(EMPTY)
	{}
};

//哈希表
template<class K, class V, class hash = HashFunc<K>>
class HashTable
{
	typedef HashNode<K, V> HashNode;
	typedef Hash_iterator<K, V, hash> iterator;
public:
	HashTable(size_t n = 10)
	{
		_table.resize(n);
	}
	
	//迭代器相关
	iterator begin();

	iterator end();	

	//查找
	HashNode* Find(const K key);
	
	//插入
	bool Insert(const pair<K, V>& kv);
	
	//删除
	bool Erase(const K key);

private:
	vector<HashNode> _table;//结点
	size_t n = 0;//存储数据个数
	hash hs;//仿函数，处理key值
};
  1. 操作实现
//查找
HashNode* Find(const K key)
{
	int hashi = hs(key) % _table.size();
	
	while (_table[hashi]._state != EMPTY)
	{
		if (_table[hashi]._state == EXIST && hs(_table[hashi]._kv.first) == hs(key))
		{
			return &_table[hashi];
		}

		hashi++;
		hashi %= _table.size();
	}

	return nullptr;
}

//插入
bool Insert(const pair<K, V>& kv)
{
	//扩容，类型转换
	//重新建立映射关系，插入(现代写法)
	if ((double)n / (double)_table.size() >= 0.7)
	{
		HashTable<K, V, hash> newtable(_table.size() * 2);
		//迭代器
		for (auto& e : _table)
		{
			newtable.Insert(e._kv);
		}

		_table.swap(newtable._table);
	}

	//找到要插入的位置
	int hashi = hs(kv.first) % _table.size();
	//线性探测
	while (_table[hashi]._state == EXIST)
	{
		if (_table[hashi]._kv.first == kv.first)
		{
			return false;
		}

		//可能越界，需要回绕
		hashi++;
		hashi %= _table.size();
	}

	//插入，单参数的构造函数支持隐式类型转换
	_table[hashi] = kv;
	_table[hashi]._state = EXIST;
	n++;

	return true;
}

//删除
bool Erase(const K key)
{
	//将要删除结点的状态改为delete
	int hashi = key % _table.size();
	
	//复用find
	HashNode* ret = Find(key);
	if (ret)
	{
		ret->_state = DELETE;
		n--;

		return true;
	}
	else
	{
		return false;
	}
}
  1. 迭代器相关接口
iterator begin()
{
	for (size_t i = 0; i < _table.size(); i++)
	{
		HashNode* cur = _table[i];
		if (cur)
		{
			return iterator(cur, this);
		}
	}

	return end();//补
}

iterator end()
{
	return iterator(nullptr, this);
}
  1. key指出，类型转换仿函数
//仿函数
template<class K>//数字类型
struct HashFunc
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};

//string类型全特化，常用
template<>
struct HashFunc<string>
{
	size_t operator()(string str)
	{
		size_t key = 0;
		for (auto e : str)
		{
			key += e;
			key *= 131;
		}
		
		return key;
	}
};

//其他类型，自定义类型
struct Date
{
	int _year;
	int _month;
	int _day;
};

struct HashDate
{
	size_t operator()(const Date& d)
	{
		size_t key = 0;
		key += d._day;
		key *= 131;//科学建议值

		key += d._month;
		key *= 131;

		key += d._year;
		key *= 131;

		return key;
	}
};

struct Person
{
	int name;
	int id;//有唯一项用唯一项，无唯一项，乘权值拼接
	int add;
	int tel;
	int sex;
};

2.3 开散列的哈希桶

2.3.1 结构描述

在这里插入图片描述

  1. 除留余数法后线性探测的存储方式会导致数据的拥堵踩踏，随着数据存储数量的增加，踩踏与拥挤的现象会越来越频繁，二次探测的优化也仅仅只是饮鸩止渴。
  2. 由此，我们来学习一种新的哈希结构也是使用最广泛的一种，其存储方式为：
    顺序表中存储链表指针，相同key值的数据构造成链表结构的数据结点，挂入同一链表中，此种数据结构就被称为哈希桶

2.3.2 开散列哈希桶实现

  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 hash = HashFunc<K>>
class HashTable
{
	typedef HashNode<K, V, hash> HashNode;
public:

	//构造
	HashTable(size_t n = 10)
	{
		_table.resize(n, nullptr);
		_n = 0;
	}

	//析构
	~HashTable()
	{
		for (size_t i = 0; i < _table.size(); i++)
		{
			HashNode* cur = _table[i];
			while (cur)
			{
				HashNode* next = cur->_next;
				delete cur;
				cur = next;
			}

			_table[i] = nullptr;
		}
	}

private:
	vector<HashNode*> _table;
	size_t _n;//插入数据个数，计算负载因子与扩容
	hash hs;//非数字类型，key值处理
	
	friend struct iterator;//迭代器会需要访问存储数据的vector
};
  1. 操作实现
//插入
bool Insert(const pair<K, V>& kv)
{
	//不支持键值冗余
	if (Find(kv.first))
		return false;

	//何时扩容，负载因子到1就扩容，插入数据个数
	if (_n == _table.size())
	{
		vector<HashNode*> newtable(2 * _table.size());

		//不再重新申请创建结点，而是搬运
		for (size_t i = 0; i < _table.size(); i++)
		{
			HashNode* cur = _table[i];
			while (cur)
			{
				HashNode* next = cur->_next;
				size_t hashi = hs(cur->_kv.first) % newtable.size();
				cur->_next = newtable[hashi];
				newtable[hashi] = cur;

				cur = next;
			}

			_table[i] = nullptr;
		}

		_table.swap(newtable);
	}

	//计算插入位置
	size_t hashi = hs(kv.first) % _table.size();

	//头插
	HashNode* newnode = new HashNode(kv);
	newnode->_next = _table[hashi];
	_table[hashi] = newnode;
	_n++;

	return true;
}

//查找
HashNode* Find(const K& key)
{
	for (size_t i = 0; i < _table.size(); i++)
	{
		HashNode* cur = _table[i];
		while (cur)
		{
			if (cur->_kv.first == key)
			{
				return cur;
			}

			cur = cur->_next;
		}
	}

	return nullptr;
}

//删除
bool Erase(const K& key)
{
	size_t hashi = hs(key) % _table.size();
	HashNode* cur = _table[hashi];
	HashNode* prev = nullptr;

	while (cur)
	{
		if (cur->_kv.first == key)
		{
			if (prev)
			{
				prev->_next = cur->_next;
			}
			else
			{
				_table[hashi] = cur->_next;
			}
			delete cur;
			_n--;

			return true;
		}

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

	return false;
}

2.3.3 哈希桶的迭代器与key值处理仿函数

  1. 迭代器结构
//将迭代器代码写于哈希桶之前
//迭代器与哈希桶存在互相引用，添加前置声明
template<class K, class V, class hash>
class HashTable;

template<class K, class V, class hash = HashFunc<K>>
struct Hash_iterator
{
	typedef HashNode<K, V> HN;
	typedef HashTable<K, V, hash> HT;
	typedef Hash_iterator Self;
	HN* _node;
	HT* _ht;
	hash hs;

	Hash_iterator(HN* node, HT* ht)
		:_node(node)
		,_ht(ht)
	{}
	
	//前置++
	Self& operator++();

	V& operator*();
	
	pair<K, V>* operator->();

	bool operator!=(const Self& it);
	
};
  1. 操作实现
//前置++
Self& operator++()
{
	if (_node->_next)
	{
		_node = _node->_next;
	}
	else
	{
		size_t hashi = hs(_node->_kv.first) % _ht->_table.size() + 1;
		_node = nullptr;//注

		while (hashi < _ht->_table.size())
		{
			if (_ht->_table[hashi])
			{
				_node = _ht->_table[hashi];
				break;
			}

			hashi++;
		}

		//后续没有元素，越界
		//_node = _ht->_table[hashi];
	}

	return *this;
}

V& operator*()
{
	return _node->_kv.second;
}

pair<K, V>* operator->()
{
	return &_node->_kv;
}

bool operator!=(const Self& it)
{
	return _node != it._node;
}
  1. 缺省的key值处理仿函数
template<class K>
struct HashFunc
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};

//特化，常用string类型
template<>
struct HashFunc<string>
{
	size_t operator()(const string& str)
	{
		size_t key = 0;
		for (auto e : str)
		{
			key += e;
			key *= 131;
		}

		return key;
	}
};

3. unordered_set与unordered_map的封装

3.1 哈希桶的细节调整

  1. 使用哈希桶unordered_set与unordered_map的封装方式与红黑树封装map，set相似，调整模板参数，使得仅用一套模板即可封装出u_map与u_set，具体操作如下：
  1. 数据结点结构的调整
template <class T>//改
struct HashNode
{
	T _kv;
	HashNode<T>* _next;

	HashNode(const T& kv)
		:_kv(kv)
		,_next(nullptr)
	{}
};
  1. 迭代器结构的调整
template<class K, class T, class KeyOfT, class hash = HashFunc<K>>
struct Hash_iterator
{
	typedef HashNode<T> HN;
	typedef HashTable<K, T, KeyOfT, hash> HT;
	typedef Hash_iterator Self;
	HN* _node;
	HT* _ht;
	hash hs;
	KeyOfT kot;
	
	//其后细节随之调整	
};
  1. 哈希桶结构的调整
//将hash模板参数的缺省值提维
template <class K, class T, class KeyOfT, class hash>
class HashTable
{
	typedef HashNode<T> HashNode;
	typedef Hash_iterator<K, T, KeyOfT, hash> iterator;
private:
	vector<HashNode*> _table;
	size_t _n;
	hash hs;
	KeyOfT kot;

	friend struct iterator;	

public:
	//其他内部方法细节随之调整
	
	//为适配上层unordered_map的operator[]，返回值与实现细节做调整
	pair<iterator, bool> Insert(const T& kv);

	iterator Find(const K& key);
};

3.2 具体封装

  1. unordered_set
//缺省提维的原因
//并非直接使用哈希桶，而是通过us，um来间接使用**
template<class K, class hash = HashFunc<K>>
class myordered_set
{
	struct KeyOfT
	{
		K operator()(const K& key)
		{
			return key;
		}
	};
	typedef Hash_iterator<K, K, KeyOfT, hash> iterator;
	typedef HashNode<K> HashNode;
public:

	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:
	HashTable<K, K, KeyOfT, hash> _ht;
};
  1. unordered_map
template<class K, class V, class hash = HashFunc<K>>
class myordered_map
{
	struct KeyOfT
	{
		K operator()(const pair<K, V>& kv)
		{
			return kv.first;
		}
	};
	typedef Hash_iterator<K, pair<K, V>, KeyOfT, hash> iterator;
	typedef HashNode<pair<K, V>> HashNode;
public:
	
	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);
	}

	V& operator[](const K& key)
	{
		pair<iterator, bool> ret = Insert(make_pair(key, V()));

		return (ret.first)->second;
	}

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

private:
	HashTable<K, pair<K, V>, KeyOfT, hash> _ht;
};
执笔者548
关注
  • 12
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C++进阶：哈希结构
碧瑶的博客呀
11-13 238
哈希相关概念 哈希：用来进行高效查找的一种数据结构 首先，我们查找的方式有： （1）顺序查找，它的时间复杂度是O(n) （2）二分查找（有序），它的时间复杂度是O(log2N) （3）利用二叉平衡搜索树（AVL、红黑树）：时间复杂度是O(log2N) （4）哈希，时间复杂度是O(1) 前三种方法元素之间都要进行比较，因此时间复杂度降不下来，而哈希元素之间不需要比较（最差情况下只需少许比较即可找到）...
C++进阶STL笔记资料.zip
07-22
这份"C++进阶STL笔记资料"将详细讲解STL的各个方面，是深入学习和掌握C++进阶技巧的重要参考资料。通过阅读和实践，开发者不仅能熟悉STL的使用，还能理解其背后的设计思想，从而更好地应对复杂的编程挑战。
C++进阶：哈希
qq_71925940的博客
06-03 597
在C++98中，STL提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到log_2N，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好的查询是，进行很少的比较次数就能够将元素找到，因此在C++11中，STL又提供了4个unordered系列的关联式容器，这四个容器与红黑树结构的关联式容器使用方式基本类似，只是其底层结构不同，本文中只对和进行介绍，和可查看文档介绍。是存储键值对的关联式容器，其允许通过keys。
C++学习进阶：哈希思想的进一步体现
weixin_73234157的博客
04-13 122
我们在之前对哈希表的学习，明白了哈希的本质就是一种映射！！！只要是实现了映射关系我们就能够说这个是“哈希”。哈希：通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。在我们实际开发中，大部分场景是处理海量的数据，例如在博客中3.3中提及的如何在40亿数据中判断某个数据在不在的问题。因为哈希映射关系的这个思路，我们最终就可以通过更小的比特位来实现数据之间的映射。
【C++进阶】：哈希
m0_73790767的博客
09-17 532
hash底层实现
C++进阶：哈希表封装unordered_map和unordered_set（模拟实现）
qq_71925940的博客
06-03 299
基于my_unordered_map.h封装的哈希表类提供的接口，实现一个unordered_map。unordered_map的值是一个键值对。基于HashTable.h封装的哈希表类提供的接口，实现一个unordered_set类。该文件基本实现了unordered_set类。该文件基本实现了unordered_map类。
c++进阶（stl资源），非原创，配套b站（C++进阶之STL）教程
02-18
**C++进阶：STL资源详解** C++标准模板库（Standard Template Library，简称STL）是C++编程中的一个重要组成部分，它提供了一系列高效、泛用的容器、迭代器、算法和函数对象，极大地提高了C++程序员的开发效率。在...
C++进阶STL源码笔记
11-15
这份“C++进阶STL源码笔记”显然是一个深入研究STL的资源，适合那些已经有一定C++编程基础的开发者，通过源码分析来提升对STL的理解和应用能力。以下将详细讲解STL中的关键组件和概念。 1. 容器： STL的核心组成...
C++开发工程师高级进阶课程-提升C++面试和开发能力.zip
01-20
《C++开发工程师高级进阶课程-提升C++面试和开发能力》的资源包，旨在帮助C++开发者进一步提升自己的专业技能，以适应更高级别的面试挑战和开发工作。这份资料集涵盖了C++语言的核心知识，包括但不限于C++面试常见...
leetcode1-200题源码（c++）
04-01
本压缩包包含了LeetCode前200题的C++实现源码，涵盖了从基础到进阶的各种算法问题，是学习和提升C++编程技巧的良好资源。下面将对其中的部分题目进行简要介绍和解析。 1. 题目80：删除排序数组中的重复项 II ...
c++习题08-计算星期几
码到成龚的博客
07-03 594
问题描述 假设今天是星期日，那么过a^b天之后是星期几？ 输入描述 两个正整数a，b，中间用单个空格隔开。0
C++初学者指南-3.自定义类型(第一部分)-析构函数
silencestarsky的博客
07-02 627
本文介绍了C++初学者指南中关于自定义类型和析构函数的重要内容。主要涵盖了特殊的成员函数如构造函数和析构函数的作用，RAII资源管理的重要性以及避免编写特殊成员函数的建议。
关键路径——C语言（理论）
2302_80790488的博客
06-28 861
关键路径，是项目网络中从起始事件到终止事件的最长路径，决定了项目的最短完成时间。 关键路径中的任务没有任何可调整的余地，如果任何一个任务被延迟，整个项目的完成时间也会被延迟。
Android 开发中 C++ 和Java 日志调试
小羊子的技术专栏
07-04 912
Android 开发中 C++ 和Java 日志调试方法小结
机器人运动范围检测 c++
m0_61862494的博客
07-02 761
地上有一个m行n列的方格，一个机器人从坐标（0，0）的格子开始移动，它每次可以向上下左右移动一个格子，但不能进入行坐标和列坐标的位数之和大于k的格子，请问机器人能够到达多少个格子。这个算法的时间复杂度为O(mn)，其中m和n分别是网格的行数和列数。空间复杂度也是O(mn)，主要用于存储visited数组和BFS队列。这个实现使用了广度优先搜索（BFS）算法来解决问题。
数学系C++ 继承派生多态 （十四十三）
最新发布
m0_68339197的博客
07-08 209
可以使得派生类具有父类的各种属性和功能，而不需要再次编写相同的代码。类的继承：派生类继承了父类的特性（数据和函数）► 继承是可传递的：从父类继承的特性可以传递给新的子类► 继承方式：规定了如何访问从父类继承的成员► 继承方式有三种：public、protected、private► 派生类成员：从父类继承的成员+新增加的成员继承方式不同，访问控制不同 父类成员函数访问父类成员：正常访问 派生类成员函数访问派生类新增成员：正常访问 父类成员函数访问派生类新增成员：不能访问。
C++：CV::Point函数简介
Ethan_Rich的博客
07-08 215
cv::Point是 OpenCV 库中用于表示二维坐标系下点的一个基本数据类型。它提供了在图像处理、计算机视觉等领域中定位和操作点的能力。以下是关于cv::Point。
c++习题09-分离整数的各个数
码到成龚的博客
07-04 218
描述 给定一个整数n(1≤n≤100000000)，要求从个位开始分离出它的每一位数字。从个位开始按照从低位到高位的顺序依次输出每一位数字。 输入描述 输入一个整数，整数在1到100000000之间。 输出描述 从个位开始按照从低位到高位的顺序依次输出每一位数字。数字之间以一个空格分开。
c++初级-2-引用
ccb1372098的博客
07-02 413
int a = 10;//引用int& b = a;b = 20;cout << "修改后" << endl;/***输出结果：a = 10b = 10修改后a = 20b = 20**/引用要求引用必须初始化。引用之后，不可以更改引用的对象。
Nginx实战进阶.pptx
10-21
Nginx实战进阶

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值