【C++】map和set的封装
write in front
所属专栏： C++学习
️博客主页：睿睿的博客主页
️代码仓库：VS2022_C语言仓库
您的点赞、关注、收藏、评论，是对我最大的激励和支持！！！
关注我，关注我，关注我，你们将会看到更多的优质内容！！
文章目录
- 前言
- 一.封装的大体思路
- 二.封装的具体实现：
-
- 1.结点的封装：
- 2.iterator的封装：
-
- set的封装:
- map的封装：
- 3.插入函数的修改：
- 4.insert在map和set里面发封装：
- 5.map的[]:
- 总结
前言
前面我们学习了红黑树的实现，而map和set的底层就是红黑树，那么我们如何使用封装map和set呢？这里我们主要是学习源码里面如何封装，我有点进入误区就是为什么不那样那样封装，其实源码这样封装肯定有他的道理，我想的怎么样封装到后面肯定会出现问题，所以一定不要纠结。因为这里确实很复杂，所以在写这篇博客的时候真的很痛苦，求大家给个赞吧呜呜呜。
一.封装的大体思路
我们通过查看源码，发现map和set的底层都是红黑树，用的同一个类模板，通过控制传不同的模板参数，从而实例化出不同的类。其实这里的红黑树就相当于一个适配器,通过我们的封装就可以使用这棵红黑树来帮我们解决问题。
二.封装的具体实现：
1.结点的封装：
通过这张图我们可以发现，红黑树在map和set里面肯定生成了不同的类，但是set只有一个key的值，此时如果要与我们之前传的V对于map而言就要改成pair。其实这里就是为了适应set只用key一个值。
map：
set：
修改后的RBtree:
结点修改后：
template<class T>
struct RBtreeNode
{
RBtreeNode<T>* _left = nullptr;
RBtreeNode<T>* _right = nullptr;
RBtreeNode<T>* _parent = nullptr;
T _data;
Colour _col = RED;
RBtreeNode(const T& data) :_data(data)
{}
};
此时就是我们每一个结点存的就是一个T类型，而不是在结点里面构造pair类型。因为其实我们结点里面本身就是存储的是key或者pair的值，如果我们自己在节点里面构造pair的值，后面的有些操作就不好处理。
2.iterator的封装：
和list的迭代器一样，map和set里面的iterator也要自己封装。这里为了区分const迭代器和普通迭代器，也是通过传入模板的类型来构造不同的迭代器。
这里有三个模板参数，
Ptr和Ref可以通过传过来的是普通参数还是const参数来控制采用什么样的迭代器（普通迭代器或者const迭代器）；同时也为map中pair的两个参数通过了很好的访问方式Ref operator*()、Ptr operator->()
template<class T,class Ptr,class Ref>
struct __TreeIterator
{
typedef RBTreeNode<T> Node;
typedef __TreeIterator<T, Ptr, Ref> Self;
typedef __TreeIterator<T, T*, T&> Iterator;
Node* _node;
//根据实例化的迭代器选择是构造还是拷贝构造
__TreeIterator(const Iterator&it)
:_node(it._node)
{}
__TreeIterator(Node* node)
:_node(node)
{}
Ref operator*()
{
return _node->_data;
}
Ptr operator->()
{
return &_node->_data;
}
bool operator!=(const Self& s) const
{
return _node != s._node;
}
bool operator==(const Self& s) const
{
return _node == s._node;
}
private:
Node* _node;
}
};
随后我们要实现++和–操作，其实++和–操作就是二叉遍历的一个另外一种过程，因为遍历的时候是有序的，说明begin是最左结点，end是空结点，与中序（左根右）不同，这里的访问顺序是从已经访问到最左结点，开始回溯到根和右结点。方法如下：
self& operator++()
{
//若右边不为空：找到右边的子树的最左结点
if (_node->_right)
{
Node* cur = _node->_right;
while (cur->_left)
{
cur = cur->_left;
}
_node = cur;
}
//若右边不为空，就要找到父亲（什么时候叫找到父亲呢？一定是左子树遍历完了才找父亲，所以说找到父亲的左子树的第一个结点之后才算找到！）
else
{
Node* cur = _node;
Node* parent = cur->_parent;
while (parent)
{
if (parent->_left == cur)
{
break;
}
else
{
cur = parent;
parent = parent->_parent;
}
}
_node = parent;
}
return *this;
}
self& operator--()
{
if (_node->_left)
{
Node* cur = _node->_left;
while (cur->_right)
{
cur = cur->_right;
}
_node = cur;
}
else
{
Node* cur = _node;
Node* parent = cur->_parent;
while (parent)
{
if (parent->_right == cur)
{
break;
}
else
{
cur = parent;
parent = parent->_parent;
}
}
_node = parent;
}
return *this;
}
随后在红黑树里面使用迭代器，便于外部使用。
template<class K,class T,class KeyOfT>
struct RBTree
{
typedef RBTreeNode<T> Node;
public:
//同一模板，不同参数实例化的不同的类型
typedef __TreeIterator<T, T*, T&> iterator;
typedef __TreeIterator<T, const T*, const T&> const_iterator; //const迭代器
//迭代器
iterator begin()
{
Node* leftMin = _root;
while (leftMin && leftMin->_left)
{
leftMin = leftMin->_left;
}
return leftMin;
}
iterator end()
{
return iterator(nullptr);
}
const_iterator begin() const
{
Node* leftMin = _root;
while (leftMin && leftMin->_left)
{
leftMin = leftMin->_left;
}
return leftMin;
}
const_iterator end() const
{
return const_iterator(nullptr);
}
// ... ...
// ... ...
}
在这里我们要明白的是，不同模板里面，如果有const值，那么两个模板是不一样的类型！！不能相互接收！！模板类要模板参数每一个参数都相同才能相互接收值。
那么，在map和set类里面该如何封装iterator呢？
set的封装:
set源码里面普通迭代器和const迭代器全部都是红黑树里面的const迭代器，所以这里的重命名是这样的：
typedef typename RBtree<K, K, SetKeyOfT>::const_iterator iterator;
typedef typename RBtree<K, K, SetKeyOfT>::const_iterator const_iterator;
//这里的const_iterator和iterator是同一个类型，都是const_iterator类型
这里要强调的就是这个模板类里面的：：因为会产生歧义，一定要标明是不是类型，加一个typename
但是这里就会出问题：
按照正常的迭代器应该这样写的：
//错误写法：
const_iterator begin()const
{
return _t.begin();
}
const_iterator end()const
{
return _t.end();
}
iterator begin()
{
return _t.begin();
}
iterator end()
{
return _t.end();
}
//这样的话除非set是const类型，都只会调用没有const修饰的那个begin，此时t返回的iterator就是普通迭代器，无法通过const迭代器接收。
但是这里却不行，因为我们的_t在调用begin()和end()函数的时候，因为_t的类型不是const，他只会调用普通迭代器的begin()和end()，而set里面全都是const_iterator。下面有两种解决方案：
方案1：
iterator begin()const
{
return _t.begin();
}
iterator end()const
{
return _t.end();
}
这里加const就修饰了*this,然后这个函数里面*this的类型就变成了const *this（范围变小），也就是set里面的所有东西的类型都变成const了，t的类型也变成了const，在用t调调用begin()，此时传的t的this指针类型就是const *this,就会调用const_iterator的那个begin()。
方案2：
在迭代器里面多写一个构造函数,这个构造函数可以用普通迭代器初始化const迭代器，解决了普通迭代器不能初始化const迭代器的问题。
typedef __TreeIterator<T, T&, T*> iterator
__TreeIterator(const iterator& it)
{
_node = it._node;
}
- const迭代器实例化，用普通迭代器初始化，此时是构造函数
- 普通迭代器实例化，用普通迭代器初始化，是拷贝构造函数
- const迭代器实例化，用cosnt迭代器初始化，是调用系统自己生成的拷贝构造函数
这个地方是一个重点！！！
map的封装：
map的key值是不允许修改的，而value是允许修改的，使用有const修饰pair里面的key值。这里的封装就和普通迭代器一样就可以了：
template<class K,class V>
class map
{
private:
struct MapKeyOfT
{
const K& operator()(const pair<const K, V>& key)
{
return key.first;
}
};
RBtree<K, pair<const K, V>, MapKeyOfT>_p;//key不能修改，value可以修改
public:
typedef typename RBtree<K, pair<const K, V>, MapKeyOfT>::iterator iterator;
typedef typename RBtree<K, pair<const K, V>, MapKeyOfT>::const_iterator const_iterator;
iterator begin()
{
return _p.begin();
}
iterator end()
{
return _p.end();
}
const_iterator begin()const
{
return _p.begin();
}
//这里加const首先是表示const迭代器指向的值不能修改（const self *this)，并且要和普通iterator重载，就要参数不同
const_iterator end()const
{
return _p.end();
}
//!!!!const int*可以接收int*也可以接收const int*，但是当有int*的时候，就会优先构成重载,在test.cpp有体现
};
3.插入函数的修改：
在前面的map和set的使用中，我们介绍了实际里面insert的返回值，是一个pair类型，所以我们要对之前的insert进行修改：
pair<iterator,bool> Insert(const T& data)
{
Node* parent = nullptr;
Node* cur = _root;
if (cur == nullptr)
{
_root = new Node(data);
_root->_col = BLACK;
return make_pair(iterator(_root),true);
}
KeyOfT get;
//找到位置：
while (cur)
{
if (get(cur->_data) > get(data))
{
parent = cur;
cur = cur->_left;
}
else if (get(cur->_data) < get(data))
{
parent = cur;
cur = cur->_right;
}
else
{
return make_pair(cur, false);
}
}
//插入：
cur = new Node(data);
cur->_col = RED;
if (get(parent->_data) < get(data))
{
parent->_right = cur;
}
else
{
parent->_left = cur;
}
cur->_parent = parent;
Node* newnode = cur;
//修改颜色：
//如果为黑色就已经正确了，当然前提是parent不为空
while (parent && parent->_col == RED)
{
Node* grandfather = parent->_parent;
if (grandfather->_left == parent)//为什么要分左右？ 找到uncle！！
{
Node* uncle = grandfather->_right;
//uncle为红的时候：
if (uncle && uncle->_col == RED)
{
//变色
uncle->_col = parent->_col = BLACK;
grandfather->_col = RED;
//向上处理
cur = grandfather;
parent = cur->_parent;
}
//uncle不存在或uncle为黑
else
{
if (parent->_left == cur)
{
//右旋
//g
//p
//c
//p
//c g
RotateR(grandfather);
//调颜色：
parent->_col = BLACK;
grandfather->_col = RED;
}
else
{
//左右旋
// g
// p
// c
// g
// c
//p
// c
//p g
RotateL(parent);
RotateR(grandfather);
cur->_col = BLACK;
grandfather->_col = RED;
}
break;
}
}
else //为什么要分左右？ 找到uncle！！
{
Node* uncle = grandfather->_left;
//uncle为红的时候：
if (uncle && uncle->_col == RED)
{
//变色
uncle->_col = parent->_col = BLACK;
grandfather->_col = RED;
//向上处理
cur = grandfather;
parent = cur->_parent;
}
//uncle不存在或uncle为黑
else
{
if (parent->_right == cur)
{
//左旋
//g
// p
// c
RotateL(grandfather);
//调颜色：
parent->_col = BLACK;
grandfather->_col = RED;
}
else
{
//右左旋：
//g
// p
//c
RotateR(parent);
RotateL(grandfather);
cur->_col = BLACK;
grandfather->_col = RED;
}
break;
}
}
}
_root->_col = BLACK;
return make_pair(iterator(newnode),true);
}
这里出现的问题就是，对于set我们可以直接用key比较大小，但是对于map传的却是pair，这个时候到底该如何比大小呢？这个时候仿函数的意义就体现出来了。
我们可以在set里面定义这样的仿函数，然后把定义的这个类当作一个类型传到模板里面去
struct SetKeyOfT
{
const K& operator()(const K& key)
{
return key;
}
};
RBtree<K, K, SetKeyOfT> _t;
map也是一样的：
struct MapKeyOfT
{
const K& operator()(const pair<const K, V>& key)
{
return key.first;
}
};
RBtree<K, pair<const K, V>, MapKeyOfT>_p;//key不能修改，value可以修改
事实上这里set在这里写这个仿函数只是工具人（就相当于你陪你你女朋友逛街一样，只是一个陪伴的效果）
4.insert在map和set里面发封装：
map里面很正常，直接封装就了，因为他的迭代器没有出什么幺蛾子：
pair<iterator,bool> insert(const pair<const K, V>& data)
{
return _p.Insert(data);
}
但是set就会有问题了：
pair<iterator,bool> insert(const K& data)
{
return _t.Insert(data);
}
在这里，我们的pair里面的iterator是const_iterator类型，而我们Insert返回的是普通的迭代器,此时pair就不能相互接收，怎么办呢？
pair<iterator,bool> insert(const K& data)
{
pair<RBtree<K, K, SetKeyOfT>::iterator, bool> ret = _t.Insert(data);
return pair<iterator, bool>(ret.first, ret.second);
}
在这里我们自己构造一个const迭代器的pair，但是这里有一个点非常重要！！！我们迭代器里面必须有普通迭代器构造const迭代器的那个函数！！也就是上面的方案2：
typedef __TreeIterator<T, T&, T*> iterator
__TreeIterator(const iterator& it)
{
_node = it._node;
}
如果没有这个函数，我们的pair在进行构造时也无法让普通迭代器转成const迭代器。
如果没有加这个构造函数：
5.map的[]:
在封装完insert之后，就可以对map的[]进行操作了：
V& operator[](const K& key)
{
auto ret = insert(make_pair(key, V()));
return ret.first->second;
}
- 如果不存在，则插入值，并返回这个值的value的引用便于修改。
- 如果存在，就返回该值的value便于你修改
当然对于const map,大家在写一个const版本的[]就可以了。
总结
这里要总结几个小点，我搞混淆的点：
- 对于重载，参数类型为
const int和int的两个函数是不能构成重载的，因为他们可以相互接收（拷贝嘛），而const指针和const引用就可以构成重载，因为他们两个在接收的时候会有权限问题。 - 对于为什么可以这样：
list<int> ss;
list<int>::const_iterator it = ss.begin();
一开始我是觉得模板传参不同，肯定不能相互接收呀，确实是这样，但是如果我们写了一个可以用普通迭代器构造const迭代器的构造函数，这个问题就可以迎刃而解！！
这能说这篇文章真的干货满满，大家好好学吧呜呜呜
更新不易，辛苦各位小伙伴们动动小手，三连走一走 ~ ~ ~ 你们真的对我很重要！最后，本文仍有许多不足之处，欢迎各位认真读完文章的小伙伴们随时私信交流、批评指正！
专栏订阅：
每日一题
C语言学习
算法
智力题
初阶数据结构
Linux学习
C++学习
更新不易，辛苦各位小伙伴们动动小手，三连走一走 ~ ~ ~ 你们真的对我很重要！最后，本文仍有许多不足之处，欢迎各位认真读完文章的小伙伴们随时私信交流、批评指正！