哈希（c++）

已于 2023-11-22 10:55:23 修改
阅读量134 收藏
点赞数
分类专栏： c++ 面向对象编程c++ 文章标签： c++ 哈希算法 开发语言
于 2023-11-22 10:55:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63783532/article/details/134495825
版权

目录

一、unordered系列关联式容器

（一）unordered_set

（二）unordered_map

练习：961. 在长度2N的数组中找出重复N次的元素

二、哈希的底层结构

（一）哈希概念

（二）哈希冲突

三、哈希冲突解决（闭散列）

（一）线性探测

1. 仿函数（将key值转整型）

2. 插入

3. 查找和删除

4. 完整代码

（二）二次探测

四、哈希冲突解决（开散列）

（一）插入

（二）删除

（三）桶的数量、最大长度、平均长度

（四）完整代码

一、unordered系列关联式容器

  • 在C++98中，STL提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到$log_2N$，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好的查询是，进行很少的比较次数就能够将元素找到，因此在C++11中，STL又提供了4个unordered系列的关联式容器，这四个容器与红黑树结构的关联式容器使用方式基本类似，只是其底层结构不同
  • 树状关联式容器（比如C++中的std::map和std::set）通常使用比较函数（仿函数）来确定元素的顺序，这样可以进行元素的大小比较。而哈希容器（比如C++中的std::unordered_map和std::unordered_set）需要将键转换为整数值，通常使用哈希函数（也是通过仿函数实现）来计算键的哈希值，然后将哈希值用于确定存储位置或进行快速查找 

（一）unordered_set

#include <iostream>
#include <unordered_set>
using namespace std;
int main()
{
    unordered_set<int>s;
    s.insert(1);
    s.insert(3);
    s.insert(5);
    s.insert(1);
    s.insert(2);

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

（二）unordered_map

  • unordered_map是存储<key, value>键值对的关联式容器，其允许通过keys快速的索引到与其对应的value。
  • 在unordered_map中，键值通常用于惟一地标识元素，而映射值是一个对象，其内容与此键关联。键和映射值的类型可能不同。
  • 在内部，unordered_map没有对<kye, value>按照任何特定的顺序排序，为了能在常数范围内找到key所对应的value，unordered_map将相同哈希值的键值对放在相同的桶中 
#include <iostream>
#include <unordered_map>
using namespace std;
int main()
{
    unordered_map<string,string>dict;
    dict["sort"] = "排序";
    dict["string"] = "字符串";


    unordered_map<string, string>::iterator it = dict.begin();
    while (it != dict.end())
    {
        cout << it->first << " "<<it->second<<endl;
        ++it;
    }
    //sort 排序
    //string 字符串
    return 0;
}

练习：961. 在长度2N的数组中找出重复N次的元素

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

class Solution {
public:
    int repeatedNTimes(vector<int>& nums) {
        int n = nums.size();
        unordered_map<int, int> m;
        for(int i=0;i<nums.size();i++)
        {
            m[nums[i]]++;
        }

        unordered_map<int, int>::iterator it = m.begin();
        while(it!=m.end())
        {
            if(it->second == n/2)
            {
                return it->first;
            }
            ++it;
        }
        return 0;
    }
};

二、哈希的底层结构

（一）哈希概念

理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。
如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。


当向该结构中：

  • 插入元素：根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放
  • 搜索元素：对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功

该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称
为哈希表(Hash Table)(或者称散列表)

（二）哈希冲突

  • 不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。
  • 把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”

三、哈希冲突解决（闭散列）

  • 闭散列：也叫开放定址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以把key存放到冲突位置中的“下一个” 空位置中去。

如何寻找下一个空位置？

（一）线性探测

hashi+i(i>=0) ，i可以是0,1,2,3

  • 从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止
hashi++;
hashi = hashi % _tables.size();
  • 如果发生越界，继续从0开始探测

1. 仿函数（将key值转整型）

模板特化中使用了一个简单的哈希算法，遍历字符串中的每个字符，将哈希值乘以一个常数（31），然后加上当前字符的 ASCII 值。这样的操作可以在一定程度上减少哈希冲突。这个特化的哈希函数适用于处理字符串类型的关键字 

//伪函数，关键字转换成无符号整型
template<class K>
struct HashFunc
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};

template<>//模板特化
struct HashFunc<string>//特化的哈希函数模板，专门用于处理 string 类型的关键字
{
	size_t hash = 0;
	size_t operator()(const string& key)
	{
		for (auto e : key)
		{
			hash *= 31;
			hash += e;
		}
		return hash;
	}
};

2. 插入

bool Insert(const pair<K, V>& kv)
{
	//负载因为0.7就扩容
	if (_n * 10 / _tables.size() == 7)
	{
		size_t newsize = _tables.size() * 2;
		HashTable<K, V> newHash;
		newHash._tables.resize(newsize);

		//遍历旧表依次将数据插入
		for (int i = 0; i < _tables.size(); i++)
		{
			if (_tables[i]._s == EXIST)
			{
				newHash.Insert(_tables[i]._kv);
			}
		}
		_tables.swap(newHash._tables);//交换旧哈希表和新哈希表

	}

	Hash hf;
	// 线性探测
	size_t hashi = hf(kv.first) % _tables.size();
	while (_tables[hashi]._s == EXIST)
	{
		hashi++;
		hashi = hashi % _tables.size();
	}
	_tables[hashi]._kv = kv;
	_tables[hashi]._s = EXIST;
	++_n;
	return true;
}

3. 查找和删除

HashData<K, V>* Find(const K& key)
{
	Hash hf;
	size_t hashi = hf(key) % _tables.size();
	while (_tables[hashi]._s != EMPTY)//容易出错
	{
		if (_tables[hashi]._s == EXIST && _tables[hashi]._kv.first == key)
		{
			return &_tables[hashi];
		}
		hashi++;
		hashi = hashi % _tables.size();//越界的时候，继续从头开始探测（查找）
	}
	return nullptr;
}

bool Erase(const K& key)//删除
{
	HashData<K, V>* ret = Find(key);
	if (ret != nullptr)
	{
		ret->_s = DELETE;//修改状态为删除
		--_n;//数据个数减少
		return true;
	}
	else
	{
		return false;
	}
}

4. 完整代码

  •  HashTable.h
#pragma once
#include<vector>
#include<string>
namespace Imitate_HashTbale
{
	enum Status//哈希表每个空间状态标记
	{
		EMPTY,//空
		EXIST,//存在数据
		DELETE//已被删除
	};

	template<class K, class V>
	struct HashData
	{
		pair<K, V> _kv;
		Status _s;//标记哈希表每个位置的状态
	};

	//伪函数，关键字转换成无符号整型
	template<class K>
	struct HashFunc
	{
		size_t operator()(const K& key)
		{
			return (size_t)key;
		}
	};

	template<>//模板特化
	struct HashFunc<string>//特化的哈希函数模板，专门用于处理 string 类型的关键字
	{
		size_t hash = 0;
		size_t operator()(const string& key)
		{
			for (auto e : key)
			{
				hash *= 31;
				hash += e;
			}
			return hash;
		}
	};


	template<class K, class V, class Hash = HashFunc<K>>
	class HashTable
	{
	public:
		HashTable()//构造函数
		{
			_tables.resize(10);
		}
		bool Insert(const pair<K, V>& kv)
		{
			//负载因为0.7就扩容
			if (_n * 10 / _tables.size() == 7)
			{
				size_t newsize = _tables.size() * 2;
				HashTable<K, V> newHash;
				newHash._tables.resize(newsize);

				//遍历旧表依次将数据插入
				for (int i = 0; i < _tables.size(); i++)
				{
					if (_tables[i]._s == EXIST)
					{
						newHash.Insert(_tables[i]._kv);
					}
				}
				_tables.swap(newHash._tables);//交换旧哈希表和新哈希表

			}

			Hash hf;
			// 线性探测
			size_t hashi = hf(kv.first) % _tables.size();
			while (_tables[hashi]._s == EXIST)
			{
				hashi++;
				hashi = hashi % _tables.size();
			}
			_tables[hashi]._kv = kv;
			_tables[hashi]._s = EXIST;
			++_n;
			return true;
		}
		HashData<K, V>* Find(const K& key)
		{
			Hash hf;
			size_t hashi = hf(key) % _tables.size();
			while (_tables[hashi]._s != EMPTY)//容易出错
			{
				if (_tables[hashi]._s == EXIST && _tables[hashi]._kv.first == key)
				{
					return &_tables[hashi];
				}
				hashi++;
				hashi = hashi % _tables.size();//越界的时候，继续从头开始探测（查找）
			}
			return nullptr;
		}

		bool Erase(const K& key)//删除
		{
			HashData<K, V>* ret = Find(key);
			if (ret != nullptr)
			{
				ret->_s = DELETE;//修改状态为删除
				--_n;//数据个数减少
				return true;
			}
			else
			{
				return false;
			}
		}
		void print()
		{
			for (int i = 0; i < _tables.size(); i++)
			{
				if (_tables[i]._s == EXIST)
				{
					cout << "[" << i << "]" << "->" << _tables[i]._kv.first << ":" << _tables[i]._kv.second << endl;
				}
			}
			cout << endl;
		}
	private:
		vector<HashData<K, V>> _tables;
		size_t _n;//存放关键字的个数
	};


	void test1()
	{
		HashTable<int, int> HT;
		int data[] = { 1,3,6,2,7,9 ,5,67,8,19 };
		for (auto ch : data)
		{
			HT.Insert(make_pair(ch, ch));
		}
		HT.print();


		if (HT.Find(99))
		{
			cout << "99存在" << endl;
		}
		else
		{
			cout << "99不存在" << endl;
		}


		if (HT.Erase(8))
		{
			cout << "成功删除8" << endl;
		}
		else
		{
			cout << "删除失败" << endl;
		}
	}

	void test2()
	{
		string arr[] = { "香蕉", "甜瓜","苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };
		HashTable<string, int> ht;

		for (auto& e : arr)
		{
			HashData<string, int>* ret = ht.Find(e);
			if (ret != nullptr)//已经存在了
			{
				ret->_kv.second++;
			}
			else
			{
				ht.Insert(make_pair(e, 1));
			}
		}
		ht.print();
	}
}
  • test.c 
#include<iostream>
using namespace std;
#include"HashTable.h"
int main()
{
	Imitate_HashTbale::test2();
	return 0;
}

（二）二次探测

hashi+i^2(i>=0)

  • 线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题 

四、哈希冲突解决（开散列）

  • 开散列法又叫链地址法(开链法)，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。

（一）插入

bool Insert(const pair<K, V>& kv)
{
	if (Find(kv.first))
		return false;

	Hash hf;

	// 负载因子最大到1
	if (_n == _tables.size())
	{
		vector<Node*> newTables;
		newTables.resize(_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 = hf(cur->_kv.first) % newTables.size();
				//采用头插
				cur->_next = newTables[hashi];
				newTables[hashi] = cur;
				cur = next;
			}
			_tables[i] = nullptr;//旧表置空
		}

		_tables.swap(newTables);
	}

	//插入结点
	size_t hashi = hf(kv.first) % _tables.size();
	Node* cur = new Node(kv);
	//采用头插
	cur->_next = _tables[hashi];
	_tables[hashi] = cur;
	++_n;
	return true;
}

（二）删除

bool Erase(const K& key)
{
	Hash hf;
	size_t hashi = hf(key) % _tables.size();
	Node* cur = _tables[hashi];
	Node* prev = nullptr;
	while (cur)
	{
		if (cur->_kv.first == key)
		{
			if (cur == _tables[hashi])//删除头结点
			{
				_tables[hashi] = cur->_next;
			}
			else
			{
				prev->_next = cur->_next;
			}
			//释放结点
			delete cur;
			cur = nullptr;
			--_n;
			return true;
		}
		else
		{
			prev = cur;
			cur = cur->_next;
		}
	}
	return false;
}

（三）桶的数量、最大长度、平均长度

void Some()
{
	size_t bucketSize = 0;//使用桶的个数
	size_t maxBucketLen = 0;//桶的最大长度
	double averageBucketLen = 0;//桶的平均长度
	size_t sum = 0;
	for (size_t i = 0; i < _tables.size(); i++)
	{
		Node* cur = _tables[i];
		if (cur != nullptr)
		{
			++bucketSize;
		}

		size_t bucketLen = 0;//记录一个桶的长度
		while (cur)
		{
			++bucketLen;
			cur = cur->_next;
		}
		sum += bucketLen;

		//记录最大的桶的长度
		if (bucketLen > maxBucketLen)
		{
			maxBucketLen = bucketLen;
		}
	}
	averageBucketLen = double(sum) / bucketSize;//桶的平均长度
	printf("all bucketSize:%d\n", _tables.size());
	printf("bucketSize:%d\n", bucketSize);
	printf("maxBucketLen:%d\n", maxBucketLen);
	printf("averageBucketLen:%lf\n\n", averageBucketLen);
}

（四）完整代码

#pragma once
#include<vector>
#include<string>
#include<cstdbool>
//namespace Imitate_hash_bucket
//{
	template<class K, class V>
	struct HashNode//结点定义
	{
		HashNode* _next;
		pair<K, V>_kv;

		HashNode(const pair<K, V>& kv)
			:_kv(kv)
			, _next(nullptr)
		{
			;
		}
	};


	//伪函数，关键字转换成无符号整型
	template<class K>
	struct HashFunc
	{
		size_t operator()(const K& key)
		{
			return (size_t)key;
		}
	};

	template<>//模板特化
	struct HashFunc<string>//特化的哈希函数模板，专门用于处理 string 类型的关键字
	{
		size_t hash = 0;
		size_t operator()(const string& key)
		{
			for (auto e : key)
			{
				hash *= 31;
				hash += e;
			}
			return hash;
		}
	};


	template<class K, class V, class Hash = HashFunc<K>>
	class HashTable
	{
		typedef HashNode<K, V> Node;
	public:
		HashTable()
		{
			_tables.resize(10);
		}
		~HashTable()
		{
			for (size_t i = 0; i < _tables.size(); i++)
			{
				Node* cur = _tables[i];
				while (cur)
				{
					Node* next = cur->_next;//cur的后驱结点
					delete cur;
					cur = next;
				}
				_tables[i] = nullptr;
			}
		}

		bool Insert(const pair<K, V>& kv)
		{
			if (Find(kv.first))
				return false;

			Hash hf;

			// 负载因子最大到1
			if (_n == _tables.size())
			{
				vector<Node*> newTables;
				newTables.resize(_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 = hf(cur->_kv.first) % newTables.size();
						//采用头插
						cur->_next = newTables[hashi];
						newTables[hashi] = cur;
						cur = next;
					}
					_tables[i] = nullptr;//旧表置空
				}

				_tables.swap(newTables);
			}

			//插入结点
			size_t hashi = hf(kv.first) % _tables.size();
			Node* cur = new Node(kv);
			//采用头插
			cur->_next = _tables[hashi];
			_tables[hashi] = cur;
			++_n;
			return true;
		}

		Node* Find(const K& key)
		{
			Hash hf;
			size_t hashi = hf(key) % _tables.size();
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					return cur;
				}
				else
				{
					cur = cur->_next;
				}
			}
			return nullptr;
		}

		bool Erase(const K& key)
		{
			Hash hf;
			size_t hashi = hf(key) % _tables.size();
			Node* cur = _tables[hashi];
			Node* prev = nullptr;
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					if (cur == _tables[hashi])//删除头结点
					{
						_tables[hashi] = cur->_next;
					}
					else
					{
						prev->_next = cur->_next;
					}
					//释放结点
					delete cur;
					cur = nullptr;
					--_n;
					return true;
				}
				else
				{
					prev = cur;
					cur = cur->_next;
				}
			}
			return false;
		}

		void Some()
		{
			size_t bucketSize = 0;//使用桶的个数
			size_t maxBucketLen = 0;//桶的最大长度
			double averageBucketLen = 0;//桶的平均长度
			size_t sum = 0;
			for (size_t i = 0; i < _tables.size(); i++)
			{
				Node* cur = _tables[i];
				if (cur != nullptr)
				{
					++bucketSize;
				}

				size_t bucketLen = 0;//记录一个桶的长度
				while (cur)
				{
					++bucketLen;
					cur = cur->_next;
				}
				sum += bucketLen;

				//记录最大的桶的长度
				if (bucketLen > maxBucketLen)
				{
					maxBucketLen = bucketLen;
				}
			}
			averageBucketLen = double(sum) / bucketSize;//桶的平均长度
			printf("all bucketSize:%d\n", _tables.size());
			printf("bucketSize:%d\n", bucketSize);
			printf("maxBucketLen:%d\n", maxBucketLen);
			printf("averageBucketLen:%lf\n\n", averageBucketLen);
		}

	private:
		vector<Node*>_tables;
		size_t _n;
	};

	void test1()
	{
		HashTable<int, int>ht;
		int data[] = { 1,4,2,7,8,12,6 };
		for (auto e : data)
		{
			ht.Insert(make_pair(e, e));
		}



		if (ht.Find(12))
		{
			cout << "12找到了" << endl;
		}
		else
		{
			cout << "未找到" << endl;
		}

		//ht.Erase(4);
		//ht.Erase(2);
	}
	void test2()
	{
		const int N = 100;
		vector<int>v;
		HashTable<int, int> ht;
		srand(time(0));
		for (size_t i = 0; i < N; i++)
		{
			v.push_back(rand() + i); // 重复值相对少
		}

		for (auto e : v)
		{
			ht.Insert(make_pair(e, e));
		}

		ht.Some();
	}

	void test3()
	{
		string arr[] = { "香蕉", "甜瓜","苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };
		HashTable<string, int> ht;
		for (auto& e : arr)
		{
			HashNode<string, int>* ret = ht.Find(e);
			if (ret)
			{
				ret->_kv.second++;
			}
			else
			{
				ht.Insert(make_pair(e, 1));
			}
		}
	}

//}

#include<iostream>
using namespace std;
#include"HashTable.h"
int main()
{
	//Imitate_hash_bucket::test3();
	test3();
	return 0;
}

莫忘、莫念
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
哈希代码C++
05-04
哈希 C++
c++的哈希表hash
03-18
c
c++中的哈希表hash
03-18
c
MD5哈希算法的C++实现（兼容大端字节序的CPU）
04-30
MD5哈希算法的C++实现（兼容大端字节序的CPU） 测试代码 #include #include #include"md5.c" int main() { using namespace std; u8 $finalHash[16] = {}; const char* str = "a"; //调用MD5 int ret = ...
哈希表 c++
03-20
哈希表的具体实现 哈希表的具体实现 c++
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 972
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 130
BCSP-X 11题 C++代码详解
LeetCode 算法：轮转数组c++
小金牛来了
06-09 643
LeetCode 算法：轮转数组c++
【C语言】一维数组（详解）
lrq13965748542的博客
06-11 966
有了下标引用操作符，我们可以轻松访问到数组中的元素了，比如我们访问下标为7的元素，我们就可以使用 arr[7]，想要访问下标为3的元素，就使用 arr[3]。我们知道数组中所有元素的类型都是相同的，那只要计算出一个元素所占字节的个数，数组的元素个数就能计算出来。以后在代码中需要数组元素个数的地方就不用固定写死了，使用上面的计算，不管数组怎样变化，计算出的大小也就随着变化了。数组也是有类型的，数组算是一种自定义类型，去掉数组名留下的就是数组的类型。实现了数组的访问，现在我们也可以实现对数组中进行数据的输入。
手搓顺序表（C语言）
m0_62646213的博客
06-12 1091
顺序表头插头删，尾插尾删，任意位置插入删除的实现和优劣分析
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
KK爱Coding的博客
06-11 257
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
基于python-CNN深度学习的食物识别-含数据集+pyqt界面
分享知识
06-10 358
本代码对数据集进行了预处理，包括通过在较短边增加灰边，使得图片变为正方形(如果图片原本就是正方形则不会增加灰边)，和旋转角度，来扩增增强数据集，运行02深度学习模型训练.py就会将txt文本中记录的训练集和验证集进行读取训练，训练好后会保存模型在本地。运行03pyqt_ui界面.py就可以有个可视化的ui界面，通过点击按钮可以加载自己感兴趣的图片识别。下载本代码后，有个requirement.txt文本，里面介绍了如何安装环境，环境需要自行配置。本代码是基于python pytorch环境安装的。
【系统学C++】从C语言到C++（三）
喜欢捣鼓各种技术
06-13 521
系统学C++
MySQL Connector/C++ 和 MySQL Connector/ODBC 的区别
程序员黄老师的精品课！
06-12 124
选择使用哪一个取决于你的具体需求，如果你正在使用C++并且希望获得更好的性能和C++友好的接口，MySQL Connector/C++可能是更好的选择。- MySQL Connector/C++ 提供了面向对象的编程接口，它是用C++编写的，提供了C++特有的类和对象来与MySQL数据库进行交互。- MySQL Connector/ODBC作为基于标准的产品，也有良好的社区支持，但由于它是跨语言的，可能在特定语言环境下的资源不如Connector/C++丰富。
C++ Primer 第五版 第16章 模板与泛型编程
最新发布
weixin_44500921的博客
06-13 543
一个函数模板（function template）就是一个公式，可用来生成针对特定类型的函数版本。模板定义以关键字template开始，后跟一个模板参数列表（template parameter list），这是一个逗号分隔的一个或多个模板参数的列表，用小于号（<）和大于号（>）包围起来。在模板定义中，模板参数列表不能为空。模板参数表示在类或函数定义中用到的类型或值。当使用模板时，我们（隐式地或显式地）指定模板实参（template argument），将其绑定到模板参数上。
手搓带头双向循环链表（C语言）
m0_62646213的博客
06-10 782
带头双向循环链表的实现与测试，优劣分析
ARM 汇编 C语言 for循环
haojie
06-12 479
在使用 Keil 编译基于 STM32F103 的 C 语言程序时，生成的汇编代码会有一些不同。使用 Keil 编译器（如 ARMCC 或 ARMCLANG）编译上述代码，生成的汇编代码可能类似于以下内容。注意，这只是一个近似的手写示例，实际生成的代码可能会有所不同。使用 Keil 编译器时，可以通过查看生成的 .lst 或 .asm 文件来查看编译后的汇编代码。实际生成的汇编代码可能会根据具体的编译器优化选项和编写的 C 代码有所不同。同时可以看下这篇文章。
C++ Easyx案例实战：Cookie Maker工作室1.0V
快乐星空Maker的博客
06-09 714
有彩蛋！
C++ opengl 纹理映射
sss_brs的博客
06-12 73
老样子，改出来的，问GPT。
哈希表c++
06-02
C++ STL 中提供了哈希表的实现，具体的类为 `unordered_map`，它是一个关联容器，提供了类似于 map 的接口，但是底层用哈希表实现，因此查找速度比 map 快。使用 `unordered_map` 的方式很简单，只需要包含头文件 `...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值