std::map源码分析

最新推荐文章于 2024-05-16 06:11:57 发布
最新推荐文章于 2024-05-16 06:11:57 发布
阅读量6.5k 收藏 1
点赞数 3
分类专栏： C、C++ 工作经历
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/boyxiaolong/article/details/17260459
版权

默认构造的时候 初始化：

	void _Init()
		{	// create head/nil node and make tree empty
		_Myhead = _Buynode();
		_Isnil(_Myhead) = true;
		_Root() = _Myhead;
		_Lmost() = _Myhead, _Rmost() = _Myhead;
		_Mysize = 0;
		}

首先会分配头结点的内存：

	_Nodeptr _Buynode()
		{	// allocate a head/nil node
		_Nodeptr _Wherenode = this->_Alnod.allocate(1);
		int _Linkcnt = 0;


		_TRY_BEGIN
		this->_Alptr.construct(&_Left(_Wherenode), 0);
		++_Linkcnt;
		this->_Alptr.construct(&_Parent(_Wherenode), 0);
		++_Linkcnt;
		this->_Alptr.construct(&_Right(_Wherenode), 0);
		_CATCH_ALL
		if (1 < _Linkcnt)
			this->_Alptr.destroy(&_Parent(_Wherenode));
		if (0 < _Linkcnt)
			this->_Alptr.destroy(&_Left(_Wherenode));
		this->_Alnod.deallocate(_Wherenode, 1);
		_RERAISE;
		_CATCH_END
		_Color(_Wherenode) = _Black;
		_Isnil(_Wherenode) = false;
		return (_Wherenode);
		}

然后设置颜色为black；设置根节点和最左、最右节点。

2、operator[]操作的时候：

	mapped_type& operator[](const key_type& _Keyval)
		{	// find element matching _Keyval or insert with default mapped
		iterator _Where = this->lower_bound(_Keyval);
		if (_Where == this->end()
			|| this->comp(_Keyval, this->_Key(_Where._Mynode())))
			_Where = this->insert(_Where,
				value_type(_Keyval, mapped_type()));
		return ((*_Where).second);
		}

第一次插入的，时候lower_bound返回头结点，因为tree是空；

_Where == this->end()为真，执行

_Where = this->insert(_Where,
value_type(_Keyval, mapped_type()));

之后会执行：

	iterator insert(const_iterator _Where,
		const value_type& _Val)
		{	// try to insert node with value _Val using _Where as a hint

 #if _HAS_ITERATOR_DEBUGGING
		if (_Where._Mycont != this)
			_DEBUG_ERROR("map/set insert iterator outside range");
 #endif /* _HAS_ITERATOR_DEBUGGING */

		const_iterator _Next;

		if (size() == 0)
			return (_Insert(true, _Myhead, _Val));	// insert into empty tree
		else if (this->_Multi)
			{	// insert even if duplicate
			if (_Where == begin())
				{	// insert at beginning if before first element
				if (!_DEBUG_LT_PRED(this->comp,
					_Key(_Where._Mynode()), this->_Kfn(_Val)))
					return (_Insert(true, _Where._Mynode(), _Val));
				}
			else if (_Where == end())
				{	// insert at end if after last element
				if (!_DEBUG_LT_PRED(this->comp,
					this->_Kfn(_Val), _Key(_Rmost())))
					return (_Insert(false, _Rmost(), _Val));
				}
			else if (!_DEBUG_LT_PRED(this->comp,
				_Key(_Where._Mynode()), this->_Kfn(_Val))
				&& !_DEBUG_LT_PRED(this->comp,
					this->_Kfn(_Val), _Key((--(_Next = _Where))._Mynode())))
				{	// insert before _Where
				if (_Isnil(_Right(_Next._Mynode())))
					return (_Insert(false, _Next._Mynode(), _Val));
				else
					return (_Insert(true, _Where._Mynode(), _Val));
				}
			else if (!_DEBUG_LT_PRED(this->comp,
				this->_Kfn(_Val), _Key(_Where._Mynode()))
				&& (++(_Next = _Where) == end()
					|| !_DEBUG_LT_PRED(this->comp,
						_Key(_Next._Mynode()), this->_Kfn(_Val))))
				{	// insert after _Where
				if (_Isnil(_Right(_Where._Mynode())))
					return (_Insert(false, _Where._Mynode(), _Val));
				else
					return (_Insert(true, _Next._Mynode(), _Val));
				}
			}
		else
			{	// insert only if unique
			if (_Where == begin())
				{	// insert at beginning if before first element
				if (_DEBUG_LT_PRED(this->comp,
					this->_Kfn(_Val), _Key(_Where._Mynode())))
					return (_Insert(true, _Where._Mynode(), _Val));
				}
			else if (_Where == end())
				{	// insert at end if after last element
				if (_DEBUG_LT_PRED(this->comp,
					_Key(_Rmost()), this->_Kfn(_Val)))
					return (_Insert(false, _Rmost(), _Val));
				}
			else if (_DEBUG_LT_PRED(this->comp,
				this->_Kfn(_Val), _Key(_Where._Mynode()))
				&& _DEBUG_LT_PRED(this->comp,
					_Key((--(_Next = _Where))._Mynode()), this->_Kfn(_Val)))
				{	// insert before _Where
				if (_Isnil(_Right(_Next._Mynode())))
					return (_Insert(false, _Next._Mynode(), _Val));
				else
					return (_Insert(true, _Where._Mynode(), _Val));
				}
			else if (_DEBUG_LT_PRED(this->comp,
				_Key(_Where._Mynode()), this->_Kfn(_Val))
				&& (++(_Next = _Where) == end()
					|| _DEBUG_LT_PRED(this->comp,
						this->_Kfn(_Val), _Key(_Next._Mynode()))))
				{	// insert after _Where
				if (_Isnil(_Right(_Where._Mynode())))
					return (_Insert(false, _Where._Mynode(), _Val));
				else
					return (_Insert(true, _Next._Mynode(), _Val));
				}
			}

		return (insert(_Val).first);	// try usual insert if all else fails
		}

因为if (size() == 0)为真

所以

	iterator _Insert(bool _Addleft, _Nodeptr _Wherenode,
		const value_type& _Val)
		{	// add node with value next to _Wherenode, to left if _Addnode
		if (max_size() - 1 <= _Mysize)
			_THROW(length_error, "map/set<T> too long");
		_Nodeptr _Newnode = _Buynode(_Myhead, _Wherenode, _Myhead,
			_Val, _Red);

		++_Mysize;
		if (_Wherenode == _Myhead)
			{	// first node in tree, just set head values
			_Root() = _Newnode;
			_Lmost() = _Newnode, _Rmost() = _Newnode;
			}
		else if (_Addleft)
			{	// add to left of _Wherenode
			_Left(_Wherenode) = _Newnode;
			if (_Wherenode == _Lmost())
				_Lmost() = _Newnode;
			}
		else
			{	// add to right of _Wherenode
			_Right(_Wherenode) = _Newnode;
			if (_Wherenode == _Rmost())
				_Rmost() = _Newnode;
			}

		for (_Nodeptr _Pnode = _Newnode; _Color(_Parent(_Pnode)) == _Red; )
			if (_Parent(_Pnode) == _Left(_Parent(_Parent(_Pnode))))
				{	// fixup red-red in left subtree
				_Wherenode = _Right(_Parent(_Parent(_Pnode)));
				if (_Color(_Wherenode) == _Red)
					{	// parent has two red children, blacken both
					_Color(_Parent(_Pnode)) = _Black;
					_Color(_Wherenode) = _Black;
					_Color(_Parent(_Parent(_Pnode))) = _Red;
					_Pnode = _Parent(_Parent(_Pnode));
					}
				else
					{	// parent has red and black children
					if (_Pnode == _Right(_Parent(_Pnode)))
						{	// rotate right child to left
						_Pnode = _Parent(_Pnode);
						_Lrotate(_Pnode);
						}
					_Color(_Parent(_Pnode)) = _Black;	// propagate red up
					_Color(_Parent(_Parent(_Pnode))) = _Red;
					_Rrotate(_Parent(_Parent(_Pnode)));
					}
				}
			else
				{	// fixup red-red in right subtree
				_Wherenode = _Left(_Parent(_Parent(_Pnode)));
				if (_Color(_Wherenode) == _Red)
					{	// parent has two red children, blacken both
					_Color(_Parent(_Pnode)) = _Black;
					_Color(_Wherenode) = _Black;
					_Color(_Parent(_Parent(_Pnode))) = _Red;
					_Pnode = _Parent(_Parent(_Pnode));
					}
				else
					{	// parent has red and black children
					if (_Pnode == _Left(_Parent(_Pnode)))
						{	// rotate left child to right
						_Pnode = _Parent(_Pnode);
						_Rrotate(_Pnode);
						}
					_Color(_Parent(_Pnode)) = _Black;	// propagate red up
					_Color(_Parent(_Parent(_Pnode))) = _Red;
					_Lrotate(_Parent(_Parent(_Pnode)));
					}
				}

		_Color(_Root()) = _Black;	// root is always black
		return (_TREE_ITERATOR(_Newnode));
		}

直接插进去了。

[]操作类似一个find操作，如果没有，就分配一个node放在正确的位置，分配颜色， 然后把迭代器的第二个值引用返回，然后再设置。

如果存在，就修改呗。擦擦擦，就是酱紫。

2、如果这样insert的时候：

    MyMap testMap;
    testMap.insert(std::make_pair(1,2));
    testMap.insert(std::make_pair(1,4));

第二次就会失败，因为它会先查找到应该插入的地方的上一个节点，如果key相等，就return (_Pairib(_Where, false));

所以不会插入滴。好吧，昨天被同事指出这段代码的问题，今天终于把代码看了下！！


xiaolomg
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
std::string std::vector std::map 源代码 结构
lacoucou的专栏
04-26 1809
// vector standard header#pragma once #ifndef _VECTOR_ #define _VECTOR_ #ifndef RC_INVOKED #include &lt;memory&gt; #include &lt;stdexcept&gt; #include &lt;xfunctional&gt; #pragma pack(push,_CRT_PACK...
MFC，C++,C语言 json转换成std::map源码,无需编译,无需关心引用位置，直接引用即可使用
09-09
mfc中引用#include "MyJson.h",就可以直接使用了，代码简单方便，总共2个个文件，安全明了，不需要复杂的引用编译，只需要一个类就可以完成json字符串转map,
stl map底层之红黑树插入步骤详解与代码实现
热门推荐
mxway的专栏
06-08 2万+
文章用图片的方式对红黑树插入过程的调整进行了详细解释。并给出红黑树插入调整实现的C++源码。
最全C++ map的简单实现_c++ map实现(2)，2024年最新4年小C C++的心路历程
2401_84975963的博客
05-16 811
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新如果你需要这些资料，可以戳这里获取 private: Node* _header; };template class Map { struct MapKeyOfValue { const K& operator()
STL源码分析：map
jmhIcoding
12-22 411
STL里面map是基于一颗红黑树来实现的，map其实是对红黑树的接口做了一下封装。 对于底层的红黑树来说，map底层的红黑树的实例化为： typedef rb_tree<key_type, value_type, select1st<value_type>, key_compare, Alloc> rep_type; 而value...
STL源码剖析之map
rabies的博客
10-23 323
#include <map> #include <iostream> #include <string> using namespace std; int main() { map<string, int> simap; // string 为key， int为value simap[string("rabbit")] = 1; simap[string("rocket")] = 2; simap[string("tiger.
map源码分析
愤怒的弱鸡
08-19 584
map可谓是最经常使用的关联容器，其实现同样基于红黑树。我们知道红黑树中一个节点保存一个value，其并没有明显的key，value概念，其在插入时比较的是value值的大小。因此我们需要对value和value的compare做一点小小的修改，这样便可以通过红黑树实现这种key，value的关联。 其实现过程类似如下代码： 我们将map的key, value作为一个整体setvalue，此setvalue便是set的value，之后重定义setvalue的compare行为，使其只比较key，经过这样的修
STL:STL源码剖析
03-24
STL源码剖析涉及对上述组件的实现细节进行分析，包括容器的内存管理、迭代器的实现原理、算法的优化策略以及函数对象的内部逻辑。通过对源码的学习，开发者可以更深入地理解C++的模板机制，提升编程效率，避免常见...
每天学点C++（C++实例教程：教程+源码）map容器.zip
最新发布
06-21
本实例教程将深入讲解`map`容器的使用方法和源码实践。 1. **map容器的基本概念** `map`是一个红黑树实现的关联容器，其中的元素是键值对。每个元素的键是唯一的，用于区分不同的元素。键值对的形式是`, value>`，...
STL.zip_analysis STLport_stl 源码分析_stlport
09-24
STLport 5.1.3版本的源码分析会详细讲解这些组件的内部工作原理，帮助开发者理解STLport如何在不同平台上优化性能，以及如何针对特定需求进行定制。通过阅读和分析源码，开发者能够提升对STL的理解，从而更好地利用...
unordered_map_unordered_map_
09-29
在C++编程语言中，`...通过分析`unordered_map.cpp`源代码，我们可以更好地理解和运用这一强大的数据结构。在实际编程中，根据具体需求选择合适的哈希函数和冲突解决策略，可以进一步优化`unordered_map`的性能。
标准模板库之map示例代码
09-17
C++入门学习——标准模板库之map,相关教程链接如下： http://blog.csdn.net/tennysonsky/article/details/48497983
c++ std 标准库源码
11-30
C++ 基本库 c++ std 标准库 源码 c++ std 标准库 源码
C++ STL : std::map
zxh2075的专栏
10-25 492
闲暇时间练习下C++ STL中std::map类的常用方法，方便以后自己复习与查阅。 更新中，如有不正确的地方，请读者及时指正，需要的话可以随意转载，谢谢！
《STL源码剖析》笔记-map
WizardtoH
10-13 498
上一篇：《STL源码剖析》笔记-set map容器的特性是所有元素都会根据键值自动排序，并且所有元素都是pair，拥有键值和实值。pair的第一个元素为键值，第二个元素为实值。map当中不允许存在两个键值相同的元素。 pair的定义 pair定义了两个模板参数，并且访问权限为public。 template &amp;amp;lt;class T1, class T2&amp;amp;gt; struct pair { ty...
STL源码分析 map容器
qq_24447809的博客
12-17 791
源代码来自sgi-2.91版本stl_map.h 文章目录map总览map类 map总览 （1）map的底层实现实际上是一颗红黑树实现，从实现原理讲，map又被称为容器适配器 （2）每次插入元素会调整红黑树位置，实现自动排序 （3）key和data是组成一个pair<T,T>值，作为红黑树的value （4）不能插入相同元素值 （5）不能修改key，但是可以修改data map类 #ifndef __STL_LIMITED_DEFAULT_TEMPLATES template <clas
stl源码剖析05——set、map源码剖析
www_dong的博客
02-19 188
一、set set语法使用参阅：https://blog.csdn.net/qq_41453285/article/details/105483473 set的特性 set所有元素都会根据元素的键值自动被排序 set中的键值就是实值，实值就是键值 默认情况下set不允许两个元素重复 set的迭代器 不能根据set的迭代器改变set元素的值。因为其键值就是实值，实值就是键值，如果改变set元素值，会严重破坏set组织 在后面的源码中会看到，set的迭代器set<T>::iter
STL源码剖析-map
INGNIGHT的专栏
08-20 640
1.容器rb_tree Red-Black tree（红黑树）是平衡二元搜寻树（balanced binary search tree）中常被使用的一种平衡二元搜寻树的特点：排列规则有利于search和insert，并保持适度平衡-无任何节点过深 rb_tree提供遍历操作以及iterators 按正常规则（++ite）遍历，便能获得排序状态（sorted） 我们不应该使用rb_tree的...
STL源码剖析 map
CHYabc123456hh的博客
11-25 1021
所有元素会根据元素的键值自动被排序 元素的类型是pair，同时拥有键值和实值；map不允许两个元素出现相同的键值 pair 代码 template <class T1,class T2> struct pair{ typedef T1 first_type; typedef T2 second_type; T1 first; //public T2 second; //public pair():first(T1()),second(T2()
std:::map转qmap
09-09
要将`std::map`转换为`QMap`，可以按照以下步骤进行操作： 1. 包含必要的头文件： ```cpp #include <map> #include <QMap> ``` 2. 创建一个`std::map`对象： ```cpp std::map<KeyType, ValueType> stdMap; ``` 3. 将数据添加到`std::map`： ```cpp stdMap[key1] = value1; stdMap[key2] = value2; // 添加更多键值对... ``` 4. 创建一个`QMap`对象： ```cpp QMap<KeyType, ValueType> qMap; ``` 5. 使用迭代器遍历`std::map`，并将数据添加到`QMap`： ```cpp for (const auto& pair : stdMap) { qMap.insert(pair.first, pair.second); } ``` 现在，您已将`std::map`成功转换为`QMap`。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值