C++：map和set的封装原理
文章目录
- 红黑树的封装
- map和set的封装
- 红黑树迭代器的实现
-
- operator ++ 和 -- 的实现
-
- ++的实现过程
- 迭代器的其他模块
- 对于实现const
-
- set的解决方案
- map的解决方案
- 整体实现
本篇写于红黑树模拟实现后，对map和set进行封装，模拟实现map和set内部的原理
首先，map和set的底层逻辑是红黑树，那么就意味着不再需要像vector/list这样重新进行写入，而是直接在红黑树的基础上进行适当的封装即可
但是，前面实现的红黑树并不能完美的适配所需要的功能，因此要在一定程度上对红黑树进行改造后，才能很好的使用，那么下面首先要对红黑树进行一定程度的改造
本篇将分析STL库中对红黑树的封装原理，搭建出基础的框架，并进行分析
红黑树的封装
拿出一份关于STL中的源码，分析源码中是如何对这这棵树进行封装的
在红黑树的定义中就不太一样，在前面实现的过程中，是直接将pair键值对当做模板中的参数的，导致只有两种，一种是Key/Key模型，一种是Key/Value模型，而在源码的实现中，则是直接将类型放到模板中来实现，用泛型的思想编程
在map和set中，传参直接将需要传递的参数传到Value处：
因此在封装的时候，就可以这样进行封装，先对我们自己完成的红黑树进行一些改善
首先，对节点进行改善
template<class T>
struct RBTreeNode
{
RBTreeNode(const T& data)
:_left(nullptr)
, _right(nullptr)
, _parent(nullptr)
, _data(data)
, _col(RED)
{}
RBTreeNode<T>* _left;
RBTreeNode<T>* _right;
RBTreeNode<T>* _parent;
T _data;
Color _col;
};
map和set的封装
下面可以对map和set进行初步封装了
namespace mymap
{
template<class K, class V>
class set
{
private:
RBTree<K, pair<K, V>> _t;
};
}
namespace myset
{
template<class K>
class set
{
private:
RBTree<K, K> _t;
};
}
下一个遇到的问题是，在插入数据的时候如何比较大小呢？例如下面的场景
上面是在模拟实现红黑树的过程中实现的逻辑，现在问题是，如何对于键值对进行比较？
在库函数中寻找对策：
比较的规则是比较键值对的第一个元素，因此现在需要做的就是想办法取出来键值对的第一个元素进行比较，因此就可以采取这样的思想，在map和set中都搞一个能把数据取出来的仿函数，在进行比较的时候返回的是Key即可，因此要修改红黑树的模板参数，接收一个仿函数的值，并用其来参与插入数据时的比较
namespace mymap
{
template<class K, class V>
class map
{
private:
struct MapKeyOfT
{
const K& operator()(const V& data)
{
// 对于map来讲，Key是传入的data键值对中的第一个元素
return data.first;
}
};
RBTree<K, pair<K, V>, MapKeyOfT> _t;
};
}
namespace myset
{
template<class K>
class set
{
public:
struct SetKeyOfT
{
const K& operator()(const K& data)
{
// 对于set来讲，K就是data本身
return data.first;
}
};
private:
RBTree<K, K, SetKeyOfT> _t;
};
}
此时基本逻辑就已经搭建起来了，在map/set中进行插入元素，实际上就是插入到树中，在外部再对这个插入的过程进行一次封装
pair<iterator,bool> insert(const V& val)
{
return _t.insert(val);
}
红黑树迭代器的实现
于是，要实现出红黑树的迭代器，红黑树的迭代器和链表的迭代器类似，都要借助一个类来构建
template<class T,class Ptr,class Ref>
struct _TreeIterator
{
typedef RBTreeNode<T> Node;
typedef _TreeIterator<T, T*, T&> Self;
// 构造函数:迭代器的本质就是封装了一层指针
_TreeIterator(Node* node)
:_node(node)
{}
// 迭代器中功能的实现
// 解引用取数据
Ref operator*()
{
return _node->_data;
}
// 取数据的地址
Ptr operator->()
{
return &(_node->_data);
}
// 实现++
// 迭代器的本质是节点的指针
Node* _node;
};
operator ++ 和 – 的实现
++的实现过程
以上图为例，此时指向的是17，从正常来说遍历次序是按照中序遍历，因此比17大的下一个数是22，总结出结论就是，++要寻找的是右孩子的最左子树，如果没有右子树如何处理？
如果没有右子树，就说明此时已经到了遍历结束了左子树，如上图所示，此时要找的是，孩子是父亲左的那个节点的祖先
根据上述逻辑，完善迭代器的代码
// 实现++
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 && cur == parent->_right)
{
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 && cur == parent->_left)
{
cur = parent;
parent = parent->_parent;
}
_node = parent;
}
return *this;
}
迭代器的其他模块
// 判断相等和不相等，实际上就是看迭代器内部封装的节点是否是同一个节点即可
bool operator==(const Self& it)
{
return _node == it._node;
}
bool operator!=(const Self& it)
{
return _node != it._node;
}
对于实现const
目前来说实现的内容已经可以使用了，但是依旧存在一些问题，比如：
#include 
这里出现的问题是，map和set中的内容可以被修改，这样会导致整个二叉树已经不是一个二叉搜索树了
在map和set库函数中的解决方案是：
set的解决方案
因此只需要按照库中的方法，就可以解决这个问题
但是，此时又会遇见下一个问题：
问题出现的原因是，这里返回的end迭代器的类型是非const版本，而要将它转换为const版本的迭代器就会出现问题，那么这又如何处理呢？
这里使用一种解决方案，这个解决方案利用了pair的一个比较好的特点：构造的方式非常灵活：
上面是关于pair的构造函数，pair最灵活的一点就是，它可以用两个不相等的模板参数来进行构造，它内部的构造函数本质上是这样写的：
template <class T1, class T2>
struct pair
{
template <class U,class V>
pair(const pair<U, V>& pr)
:first(pr.first)
,second(pr.second)
{}
T1 first;
T2 second;
};
也就是说，T1，T2，U，V都可以不相等，只需要它们之间存在合适的构造函数进行构造就可以了，因此利用这一点，将红黑树中的insert的返回值，返回一个节点的指针，利用节点的指针来构造set中返回的值就可以了
pair<iterator, bool> insert(const K& val)
{
return _t.insert(val);
}
map的解决方案
map的解决方案是，直接在map的源头根治，把pair的第一个元素设置为const即可
整体实现
改造过后的红黑树
#pragma once
#include 依据红黑树封装出的set
#pragma once
#include "RBTree.h"
namespace myset
{
template<class K>
class set
{
public:
struct SetKeyOfT
{
const K& operator()(const K& data)
{
// 对于set来讲，K就是data本身
return data;
}
};
typedef typename RBTree<K, K, SetKeyOfT>::const_iterator iterator;
typedef typename RBTree<K, K, SetKeyOfT>::const_iterator const_iterator;
pair<iterator, bool> insert(const K& val)
{
return _t.insert(val);
}
iterator begin() const
{
return _t.begin();
}
iterator end() const
{
return _t.end();
}
private:
RBTree<K, K, SetKeyOfT> _t;
};
}
依据红黑树构造出的map
#pragma once
#include "RBTree.h"
namespace mymap
{
template<class K, class V>
class map
{
public:
struct MapKeyOfT
{
const K& operator()(const pair<K, V>& data)
{
// 对于map来讲，key是键值对的第一个元素
return data.first;
}
};
typedef typename RBTree<K, pair<const K, V>, MapKeyOfT>::iterator iterator;
typedef typename RBTree<K, pair<const K, V>, MapKeyOfT>::const_iterator const_iterator;
pair<iterator, bool> insert(const pair<K, V>& val)
{
return _t.insert(val);
}
iterator begin()
{
return _t.begin();
}
iterator end()
{
return _t.end();
}
const_iterator begin() const
{
return _t.begin();
}
const_iterator end() const
{
return _t.end();
}
private:
RBTree<K, pair<const K, V>, MapKeyOfT> _t;
};
}