哈希(14)(下)

原创 已于 2025-12-18 20:18:21 修改 · 489 阅读 · 12 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #数据结构 #学习

于 2025-12-18 20:15:43 首次发布

新星杯·14天创作挑战营·第18期 10w+人浏览 180人参与

        https://blog.csdn.net/qscftqwe/article/details/156021173

        上节课链接，配套使用更佳


一.闭散列代码实现

        1.1 提要

#pragma once
#include <iostream>
#include <vector>
enum State//状态
{
	Empty,//空
	Exist,//存在
	Delete//删除
};
struct HashData
{
	State _state = Empty;//元素的状态
	int _val = 0;//元素的值
};
class HashTable
{
	typedef HashData Data;
public:
	HashTable()
	{
		_table.resize(10);
	}
private:
	std::vector<Data> _table;
    //这里的n是为了统计哈希表里面的有效数据，是为了和vector的size_t做区别
	size_t _n = 0;
};

        关于状态这个枚举，我在后面讲解的时候会进行分析，还有一点要注意的就是我这个_table这个应该是Data*的我写成Data，不是说错了而是说前者更推荐，我这次写的有问题！

        1.2 插入

//线性探测
bool Insert(int val)
{
	//不允许重复插入
	Data* ret = Find(val);
	if (ret != nullptr)
	{
		return false;
	}
	//扩容
	if (((double)_n / _table.size() >= 0.7))
	{
		size_t newSize = _table.size() * 2;//扩两倍
		//创建新表
		std::vector<Data> newTable(newSize);
		// 从老哈希表插入
		for (auto& data : _table) 
		{
			if (data._state == Exist) 
			{
				size_t hashi = (data._val % newSize + newSize)% newSize;
                
				while (newTable[hashi]._state == Exist) 
				{
                    //该位置不为空不可以插入要往前走
					hashi = (hashi + 1) % newSize; // 线性探测
				}

                //该位置为空或删除可以插入
				newTable[hashi] = data;
			}
		}
		//交换新表和旧表
		_table.swap(newTable);
	}

	//增加

    //求该值在哈希表的位置
	size_t hashi = (val % _table.size() + _table.size()) % _table.size();
	//看看哈希表该值是否存在
	while (_table[hashi]._state == Exist)
	{
		++hashi;
		hashi = hashi % _table.size();//避免值超出范围了
	}
	//为空或者为删除
	_table[hashi]._val = val;
	_table[hashi]._state = Exist;
	++_n;//加入成功
	return true;
}

       注意：闭散列和开散列的插入都是不能有重复的元素的！

        关于这个Insert要重点讲扩容这部分！

        扩容：

  1.  哈希表的扩容和传统的扩容是不一样的，传统的扩容都是满了才扩，而哈希表它因为有哈希冲突因此引进负载因子，我们是根据负载因子来扩容的！
  2. 然后我们在讲一下为什么要引入状态吧，首先我们知道数组最大的劣势就是删数据要用O(n)进行搬运，我们之前处理vector的时候是为什么可以直接用有效个数--即可完成，因为我们vector是线性序列的数据结构，因此它要插入的位置是可视化（即我们知道它要插哪里）
  3. 但是哈希表它是关联性容器，所以它要插入的位置是不可视化的，因此我们无法通过有效个数--来完成对数据的删除，因此我们用状态来表示是否经行删除，引进状态我们就知道数组的终点是那个位置（empty）而删除状态表明该坑为空里面的数据无效，最后exist状态表明该坑不为空里面数据有效。
  4. size_t hashi = (data._val % newSize + newSize)% newSize;
hashi = (hashi + 1) % newSize;

    然后就是介绍这两条代码，首先第一条它是避免val是负数的情况，这是安全取摸法，第二条这个和循环队列有点像就是都有一个从头走的概念！

        最后关于后面的增加就不需要在讲了，因为扩容它本身就有包含增加这种！不过可能有些人会对这三行代码有疑问！


newTable[hashi] = data;

_table[hashi]._val = val;
_table[hashi]._state = Exist;

        你可能会疑惑为什么从老哈希表插入，不需要修改值和状态，注意data是Data类型也就是说它包含这val和state，后面的就不必多说了！

        1.3 查找

Data* Find(int val)
{
    //保存开始位置
	size_t start = (val % _table.size() + _table.size()) % _table.size();
	size_t hashi = start;

	//对数组进行查找
	do {
		if (_table[hashi]._state == Empty)
			return nullptr; // 真空位置 → 不存在

		if (_table[hashi]._state == Exist && _table[hashi]._val == val) 
		{
			return &_table[hashi];//找到了
		}
		hashi++;
		hashi = hashi  % _table.size();
	} while (hashi != start); // 防止死循环

	//当找到空那么说明该数组所有元素都被查询完毕
	return nullptr;
}

        要点：

        一定要采用do while循环，因为一开始hahsi==start，如果先判断那么就直接退出了，而在查找这一个函数当中你就更能明白状态的重要性！

        为什么返回类型要是Data*类型，因为在学习插入和删除，你发现他们都可以借助查询功能，因此才会被设计成Data*类型！

        1.4 删除 

bool Erase(int val)
{
	Data* ret = Find(val);
	if (ret != nullptr)
	{
		ret->_state = Delete;
		--_n;
		return true;
	}
	return false;
}

        如果用上查询，那么删除其实非常的简单，就不做讲解了

        1.5 完整代码

#pragma once
#include <iostream>
#include <vector>
enum State//状态
{
	Empty,//空
	Exist,//存在
	Delete//删除
};
struct HashData
{
	State _state = Empty;//元素的状态
	int _val = 0;//元素的值
};
class HashTable
{
	typedef HashData Data;
public:
	HashTable()
	{
		_table.resize(10);
	}
	//线性探测
	bool Insert(int val)
	{
		//不允许重复插入
		Data* ret = Find(val);
		if (ret != nullptr)
		{
			return false;
		}
		//扩容
		if (((double)_n / _table.size() >= 0.7))
		{
			size_t newSize = _table.size() * 2;//扩两倍
			//创建新表
			std::vector<Data> newTable(newSize);
			// 从老哈希表插入
			for (auto& data : _table) 
			{
				if (data._state == Exist) 
				{
					size_t hashi = (data._val % newSize + newSize)% newSize;
					while (newTable[hashi]._state == Exist) 
					{
						hashi = (hashi + 1) % newSize; // 线性探测
					}
					newTable[hashi] = data;
				}
			}
			//交换新表和旧表
			_table.swap(newTable);
		}

		//增加
    
        //求该值在哈希表的位置
		size_t hashi = (val % _table.size() + _table.size()) % _table.size();

		//看看哈希表该值是否存在
		while (_table[hashi]._state == Exist)
		{
			++hashi;
			hashi = hashi % _table.size();//避免值超出范围了
		}
		//为空或者为删除
		_table[hashi]._val = val;
		_table[hashi]._state = Exist;
		++_n;//加入成功
		return true;
	}
	Data* Find(int val)
	{
        //获取一开始位置
		size_t start = (val % _table.size() + _table.size()) % _table.size();

		size_t hashi = start;

		//对数组进行查找
		do {
			if (_table[hashi]._state == Empty)
				return nullptr; // 真空位置 → 不存在

			if (_table[hashi]._state == Exist && _table[hashi]._val == val) 
			{
				return &_table[hashi];//找到了
			}
			hashi++;
			hashi = hashi  % _table.size();
		} while (hashi != start); // 防止死循环

		//当找到空那么说明该数组所有元素都被查询完毕
		return nullptr;
	}
	bool Erase(int val)
	{
		Data* ret = Find(val);
		if (ret != nullptr)
		{
			ret->_state = Delete;
			--_n;
			return true;
		}
		return false;
	}
private:
	std::vector<Data> _table;

    //这里的n是为了统计哈希表里面的有效数据，是为了和vector的size_t做区别
	size_t _n = 0;
};

二.开散列的代码实现

        1.提要

//节点
struct HashNode
{
	HashNode(int val)
		:_val(val)
		,_next(nullptr)
	{}
	int _val;
	HashNode* _next;
};
class HashBucket
{
	typedef HashNode Node;
	typedef HashBucket Self;
public:
	HashBucket()
	{
		_table.resize(10, nullptr);
	}
    HashBucket(const Self& Bucket)
    {
	    size_t newSize = Bucket._table.size();
	    _n = Bucket._n;
	    _table.resize(newSize,nullptr);
	    //拷贝数据
	    for (size_t i = 0; i < Bucket._table.size(); i++)
	    {
		    Node* cur = Bucket._table[i];
		    while (cur)
		    {
			    Node* newNode = new Node(cur->_val);//用老链表的节点构建新链表

		    	size_t hashi = (newNode->_val % newSize + newSize) % newSize;

		    	//类似挂咸鱼的那种挂法，把钩子的第一条咸鱼挂在该咸鱼下面
                //然后把咸鱼挂在钩子上面
			    newNode->_next = _table[hashi];
		    	_table[hashi] = newNode;

		    	cur = cur->_next;
		    }
	    }
    }
	~HashBucket()
	{
		for (size_t i = 0; i < _table.size(); i++)
		{
			Node* cur = _table[i];
			while (cur)
			{
				Node* next = cur->_next;
				delete cur;
				cur = next;
			}
			_table[i] = nullptr;
		}
	}
private:
	std::vector<Node*>_table;
	size_t _n = 0;
};

        关于这部分重点要讲的就是拷贝构造和

        拷贝构造：

  1. 首先我们要大概清楚哈希桶（开散列）大概是长什么样的，这个我上一章也讲，不过这里同样贴出！
  2. 其实你根据这张图片你就知道了这是由两种数据结构组成的：数组和链表，每一个数组存放的就是一条链表，所以我们要拷贝就是把这数组中的所有链表拷过去！
  3. 我们知道要把链表拷过去但是这么拷过去呢，首先我们单链表它头插是不是O(1)，所以我们采用头插的方法，关于哈希桶实用头插的方法就有点像挂咸鱼，首先你有一条咸鱼，然后你会把钩子上的一串咸鱼取下来然后把这一串咸鱼挂在当前这个咸鱼下面，刮完后再把新的一串咸鱼挂在钩子上。

        至于析构就没什么好说的了，就是循环所有链表然后一 一删除链表上的节点即可！

        1.2 插入        

bool Insert(int val)
{
	Node* ret = Find(val);//看看这个有没有重复
	if (ret != nullptr)
		return false;
	//负载因子为1在扩容
	if (_n == _table.size())
	{
		size_t newSize = _table.size() * 2;
		std::vector<Node*>table;
		table.resize(newSize, nullptr);
		//遍历旧表到新表
		for (size_t i = 0; i < _table.size(); i++)
		{
			Node* cur = _table[i];//获取链表的第一个节点
			while (cur)
			{
				Node* next = cur->_next;
				//头插到新表
                //获取要插在那个桶里面
				size_t hashi = (cur->_val % newSize + newSize) % newSize;

				//类似挂咸鱼的那种挂法，把钩子的第一条咸鱼挂在该咸鱼下面
                //然后把咸鱼挂在钩子上面
				cur->_next = table[hashi];
				table[hashi] = cur;

				cur = next;

			}
		}
		//交换新表和旧表
		_table.swap(table);
	}

	size_t hashi = (val % _table.size() + _table.size()) % _table.size();

	//头插
	Node* newNode = new Node(val);
	newNode->_next = _table[hashi];
	_table[hashi] = newNode;
	++_n;
	return true;
}

        至于这个插入代码，其实你只要会闭散列的插入+拷贝构造用的方法，其实这个有没什么好说的，看我代码注释自己理解即可！

        最后关于这个负载因子这么说呢，可以调成70%，不过我上节课讲的是100%，那我这边就采取100%的写法，当然70会更好的！

        1.3 查找

Node* Find(int val)
{
	size_t hashi = (val % _table.size() + _table.size()) % _table.size();
	Node* cur = _table[hashi];
	while (cur)
	{
		if (cur->_val == val)
		{
			//找到了
			return cur;
		}
		cur = cur->_next;
	}
	return nullptr;
}

        代码不做讲解！

        1.4 删除

bool Erase(int val)
{
	size_t hashi = (val % _table.size() + _table.size()) % _table.size();
	Node* cur = _table[hashi];//记录要删除的节点
	Node* prev = nullptr;//删除节点的上一个节点
	while (cur)
	{
		if (cur->_val == val)
		{
			//删除的刚好是第一个节点
			if (prev == nullptr)
			{
				prev = cur->_next;
				_table[hashi] = prev;
			}
			else//删除的不是第一个节点
			{
				prev->_next = cur->_next;
			}
			delete cur;
			--_n;
			return true;
		}
		prev = cur;
		cur = cur->_next;
	}
	return false;
}

        这个重点部分就是单链表删除会遇到的问题，就是你删除的节点正好是链表的第一个节点该怎么处理的，只要注意这个处理删除和之前处理析构差不多！

        1.5 完整代码

#pragma once
#include <iostream>
#include <vector>
class HashBucket
{
	typedef HashNode Node;
	typedef HashBucket Self;
public:
	HashBucket()
	{
		_table.resize(10, nullptr);
	}
	HashBucket(const Self& Bucket)
	{
		size_t newSize = Bucket._table.size();
		_n = Bucket._n;
		_table.resize(newSize,nullptr);
		//拷贝数据
		for (size_t i = 0; i < Bucket._table.size(); i++)
		{
			Node* cur = Bucket._table[i];
			while (cur)
			{
				Node* newNode = new Node(cur->_val);//用老链表的节点构建新链表
                //安全获取位置
				size_t hashi = (newNode->_val % newSize + newSize) % newSize;

				//类似挂咸鱼的那种挂法，把钩子的第一条咸鱼挂在该咸鱼下面
                //然后把咸鱼挂在钩子上面
				newNode->_next = _table[hashi];
				_table[hashi] = newNode;

				cur = cur->_next;
			}
		}
	}
	~HashBucket()
	{
		for (size_t i = 0; i < _table.size(); i++)
		{
			Node* cur = _table[i];
			while (cur)
			{
				Node* next = cur->_next;
				delete cur;
				cur = next;
			}
			_table[i] = nullptr;
		}
	}
	bool Insert(int val)
	{
		Node* ret = Find(val);//看看这个有没有重复
		if (ret != nullptr)
			return false;
		//负载因子为1在扩容
		if (_n == _table.size())
		{
			size_t newSize = _table.size() * 2;
			std::vector<Node*>table;
			table.resize(newSize, nullptr);
			//遍历旧表到新表
			for (size_t i = 0; i < _table.size(); i++)
			{
				Node* cur = _table[i];//获取链表的第一个节点
				while (cur)
				{
					Node* next = cur->_next;
					//头插到新表
                    //获取要插在那个桶里面
					size_t hashi = (cur->_val % newSize + newSize) % newSize;
		
					cur->_next = table[hashi];
					table[hashi] = cur;

					cur = next;

				}
			}
			//交换新表和旧表
			_table.swap(table);
		}

		size_t hashi = (val % _table.size() + _table.size()) % _table.size();

		//头插
		Node* newNode = new Node(val);
		newNode->_next = _table[hashi];
		_table[hashi] = newNode;
		++_n;
		return true;
	}
	Node* Find(int val)
	{
		size_t hashi = (val % _table.size() + _table.size()) % _table.size();
		Node* cur = _table[hashi];
		while (cur)
		{
			if (cur->_val == val)
			{
				//找到了
				return cur;
			}
			cur = cur->_next;
		}
		return nullptr;
	}
	bool Erase(int val)
	{
		size_t hashi = (val % _table.size() + _table.size()) % _table.size();
		Node* cur = _table[hashi];//记录要删除的节点
		Node* prev = nullptr;//删除节点的上一个节点
		while (cur)
		{
			if (cur->_val == val)
			{
				//删除的刚好是第一个节点
				if (prev == nullptr)
				{
					prev = cur->_next;
					_table[hashi] = prev;
				}
				else//删除的不是第一个节点
				{
					prev->_next = cur->_next;
				}
				delete cur;
				--_n;
				return true;
			}
			prev = cur;
			cur = cur->_next;
		}
		return false;
	}
private:
	std::vector<Node*>_table;
	size_t _n = 0;
};

        C++哈希表的实现就是采用开散列（哈希桶）的方式实现的，不过我所展现的是非常简单的，因为哈希表分成unordered_map和unordered_set，因此还要对此进行封装，然后加上封装、迭代器……就会太复杂了，所以无论是哈希还是map/set都没有像之前一样实现的更彻底！

算法：哈希表
uncle_ll的博客
03-25 3105
哈希表简介 哈希表：也叫做散列表。是根据关键字和值（Key-Value）直接进行访问的数据结构。也就是说，它通过关键字 key 和一个映射函数 Hash(key) 计算出对应的值 value，然后把键值对映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做哈希函数（散列函数），用于存放记录的数组叫做 哈希表（散列表）。 哈希表的关键思想是使用哈希函数，将键 key 和值 value 映射到对应表的某个区块中。可以将算法思想分为两个部分： 向哈希表中插入一个关键字：哈希函数决定该关键字的对应值应
哈希指纹技术详解：从原理到应用
AI天才研究院
04-27 559
哈希函数HHHHD→RHD→R其中DDD是可能的输入数据域，RRR是哈希值域，通常∣D∣≫∣R∣∣D∣≫∣R∣。哈希指纹技术通过将复杂数据转换为简短的数字摘要，实现了海量数据的高效比较和检索。从简单的文件校验到复杂的区块链系统，从文本查重到分布式存储去重，哈希指纹已经成为现代信息技术的基础设施之一。随着数据规模的不断增长和应用场景的多样化，哈希指纹技术将继续演化，应对新的挑战和需求。
哈希（Hash）
2401_88885149的博客
06-06 4309
简单介绍了一下什么是哈希，然后进行了一下算法举例
14 哈希表和哈希桶
精致的灰的博客
01-17 4141
文章目录一、哈希表二、哈希函数2.1. 直接定址法(常用)2.2. 除留余数法(常用)2.3. 几种不常用的方法三、哈希冲突四、闭散列4.1. 线性探测4.2. 负载因子4.3. 二次探测4.4. 插入和删除操作4.5. 扩容操作4.6. 代码实现五、开散列（哈希桶）5.1. 开散列扩容5.2. 代码实现六、闭散列和开散列的比较 一、哈希表 哈希表（Hash table，也叫散列表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，通过
分布式Redis（14）哈希槽
蘑菇蘑菇不会开花的专栏
09-19 1712
Redis 是一款广泛使用的高性能键 - 值存储数据库。在数据分片方面，Redis 采用了哈希槽（Hash Slot）的方式，而非一致性哈希（Consistent Hashing），这是基于多方面的考量。Redis 集群预先分配了 16384 个哈希槽。这种固定数量的哈希槽使得数据分布的管理更加容易。每个节点负责一定数量的哈希槽，例如，在一个有 N 个节点的集群中，每个节点大致负责 16384/N 个哈希槽。相比之下，一致性哈希的数据分布相对更 “自由”，可能导致在节点数量变化时数据迁移的不可预测性增加。
哈希查找算法
灰灰老师
09-26 1594
②数据量够大的时候，空间浪费足够小，因为d(i)是我们自定义的，平方数越大索引计算出来的位置间隔越大，产生数据冲突的可能性越小，同时也就会留下更多的空隙，那就是牺牲了一部分空间来换取了很小的冲突，说白了就是牺牲空间换取时间的做法。(2): d(i) = 1²，2²，3²，4²,....,或者d(i) = -1²，-2²，-3²，-4².....，这种取法称为平方探测法。举例：通讯录找人，第一步找z，赵、张--->肉眼去看“张”这个字 ---->点开“张三”这个人，然后你就看到了他的电话号码。
C++基础（14. 哈希 ）
2301_79903399的博客
11-27 1154
1.哈希概念哈希(hash)又称散列，是⼀种组织数据的⽅式。从译名来看，有散乱排列的意思。本质就是，查找时通过这个哈希函数计算出Key存储的位置，进行快速查找。1.1直接定址法当关键字的范围⽐较集中时，直接定址法就是非常简单高效的⽅法eg1：⼀组关键字都在[0,99]之间， 那么我们开⼀个100个数的数组，每个关键字的值直接就是存储位置的下标。eg2：⼀组关键字值都在[a,z]的小写字母，那么我们开⼀个26个数的数组，每个关键字acsii码-a ascii码就是存储位置的下标。
字符串哈希
helloworld_fish的博客
03-22 1126
字符串哈希其实就是把一段字符串转化成一个数字。在进行字符串匹配时不需要再 O (n)匹配字符串本身，而只需要匹配两个字符串的哈希值就好了O（1）
C++之哈希
ZZY5707的博客
11-27 1209
以及。
数据结构——哈希
hu_143的博客
07-17 1852
数据结构——哈希新鲜出炉，快来围观吧~~~
哈希和哈希表
qq_28203439的博客
01-26 1015
hash的定义：Hash一般翻译为散列，哈希是指一个过程，这个过程就是把任意长度的输入，通过哈希算法，变换成固定长度的输出，所输出的称为哈希值。这种变换是一种压缩映射，也即哈希值所占的空间一般来说远小于输入值的空间，不同的输入可能会哈希出相同的输出（概率很小）。hash值的作用：数据的哈希值可以检验数据的完整性。一般用于快速查找和加密算法哈希的特点：如果两个哈希值是不相同的（根据同一函数），那么这两个散列值的原始输入一定是不相同的。
14、【C++】哈希
gamblerofdestinyR14的博客
12-04 907
基本类型（int、double等）可直接使用std::hash// 哈希值int _age;// 特化std::hash<Person>// 组合姓名和年龄的哈希值// 使用自定义类型// 实现哈希函数// 指定哈希对象。
数据结构——哈希表、哈希桶
mastershooter的博客
06-03 1772
此时，我们可根据哈希表的大小，选择其中各种符号分布均匀的若干位作为哈希地址。顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较，顺序查找时间复杂度为O(N),平衡树中为树的高度,即O(logN),搜索的效率取决于搜索过程种元素的比较次数。与闭散列的哈希表不同的是，在实现开散列的哈希表时，我们不用为哈希表中的每个位置设置一个状态字段，因为在开散列的哈希表中，我们将哈希地址相同的元素都放到了同一个哈希桶中，并不需要经过探测寻找所谓的“下一个位置”。
哈希
ben1010101010的博客
03-30 755
哈希表（Hash Table，也叫散列表），是根据关键码值 (Key-Value) 而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。哈希表的实现主要需要解决两个问题，哈希函数和冲突解决。 哈希函数 对比二叉排序树 二叉平衡树 红黑树 B B+树，它们的查找都是先从根节点进行查找，从节点取出数据或索引与查找值进行比较。那么，有没有一种函数H，根...
Robin Hood 哈希：C++11/14下的快速内存高效哈希表
资源摘要信息:"robin-hood-hashing：基于C++11/14/17的基于robin hood哈希的快速且内存高效的哈希表" 知识点详细说明： 1. C++版本支持与特性 标题中提及了“基于C++11/14/17”，这表明该哈希表实现支持C++的多个...
C++ -- 哈希表
2301_80059080的博客
12-12 1435
本文系统介绍了哈希表的核心概念与实现方法。首先阐述了哈希的基本思想：通过哈希函数建立键值与存储位置的映射关系，实现O(1)时间复杂度的操作。然后详细讲解了哈希函数设计（包括除法散列法、乘法散列法等）和冲突处理策略，重点分析了开放定址法（线性探测、二次探测、双重散列）和链地址法两种主要冲突解决方案。文章还提供了完整的C++实现代码，包括哈希表结构设计、扩容机制、插入/查找/删除操作等关键算法，并通过示例演示了哈希表的工作过程。最后比较了不同方法的优缺点，指出链地址法在实践中的优势。
【C++】--AVL树的认识和实现
2302_81083101的博客
12-14 873
前面我们学习了二叉搜索树，其在一般情况下，对数据的查找的效率为O(logN)，但是在极端的情况下，其时间复杂度会达到O(n)。如下：右边的单支或者接近单支的情况就会导致查找的效率变得很低。所以后来又发明了AVL树，AVL树是两个前苏联科学家在1962年发表的。其概念如下：AVL树最先发明自平衡二叉查找树，其是一棵空树，或者具有以下性质的二叉树，它的左右子树也都是AVL树，然后左右子树的高度差不能超过1。AVL树是一棵高度平衡二叉树，其通过控制高度差去控制平衡。
如何快速在 VS2026 上使用 C++ 模块 — 完整上手指南
最新发布
charlie114514191的博客
12-15 813
本文介绍了在VS2026中使用C++20模块特性的完整指南。文章首先阐述了模块的优势，如增量编译和更健壮的导出机制。接着提供了使用前提条件，包括VS2026的安装和C++标准设置。通过一个包含模块接口单元(math.ixx)和主程序(main.cpp)的最小示例，详细说明了模块的创建和使用方法。最后，文章指导读者在VS2026 IDE中配置项目、添加模块文件并设置语言标准，以顺利构建运行模块化程序。文末还提供了微软官方的相关参考资料。
Re:从零开始学C++（一）基础精讲·上篇：命名空间、输入输出、缺省参数、函数重载
Z2314246476的博客
12-11 1420
本文系统介绍了C++语言的核心特性，包括命名空间、输入输出流、缺省参数和函数重载四大重点内容。命名空间部分详细讲解了如何解决C语言中的命名冲突问题，通过namespace关键字创建独立域；输入输出流章节分析了cout/cin的工作原理及使用技巧；缺省参数部分阐释了全缺省和半缺省参数的设置规则；函数重载章节则说明了通过参数个数、类型和顺序实现多态调用的方法。文章采用理论讲解与代码示例相结合的方式，深入浅出地剖析了C++相较于C语言的改进之处，适合C++初学者系统学习这些基础但重要的语言特性。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值