1. 关联式容器的对比
- 在C++98中,STL提供了底层为红黑树的关联式容器,如:set、map等,查询效率为O(longn),即最差情况下需要比较红黑树的高度次,当节点数目很多时,需要比较的次数多,查询效率低。在C++11中,STL提供了4个unordered系列的关联式容器,如:unordered_set、unordered_map等,底层结构为哈希表,通过存储值和存储位置的映射的关联关系,查询效率可以达到常数级别,即:O(1)。
- unordered_map、unordered_set底层结构为哈希结构,其容器内元素的顺序是无序的,单向迭代器。map、set底层结构为红黑树结构,其其容器内元素的顺序是有序的,双向迭代器。两者的成员函数使用方式基本相同、都有multi版本、key是唯一的。
- 在性能上差别:对于插入、删除操作,如果容器中元素重复值很多 或者 元素重复值不是很多时,map、set效率低于unordered_map、unordered_set。如果容器中元素无重复值时,map、set效率优于unordered_map、unordered_set。因为unordered系列容器存在哈希冲突、扩容有消耗,导致效率降低。
2. 哈希结构
2.1 概念
概念:存储值和存储位置的映射的关联关系。
-
顺序结构和平衡树,关键码和存储位置未建立关联关系,因此在查找元素时,关键码需要进行多次比较。顺序结构的查找效率为O(n),平衡树的查找效率为高度次O(longn)。搜索效率取决于在搜索过程中关键码比较的次数。
-
哈希方法的思想:在元素关键码k和元素存储位置p之间建立起一一映射关联关系H,使得p = H(k),H为哈希函数。因此在查找时,通过哈希函数(hash(key) = key%size=存储位置)的转化,使得查询效率达到常数级别,即:O(1)。
-
哈希方法中,使用的转换函数称为哈希函数(散列函数),构造出来的结构称为哈希表(散列表)。
2.2 哈希冲突
概念:不同的关键码通过同一哈希函数计算出相同的存储位置,称为哈希冲突或者哈希碰撞。把具有不同关键码而具有相同存储位置的数据元素称为"同义词”。
问:为什么会引起哈希冲突妮?
答:引起哈希冲突的一个原因可能是:哈希函数设计不够合理。
2.3 哈希函数
2.3.1 哈希函数设计原则
-
哈希函数的定义域必须包含需存储的全部关键码。若哈希表中有n个地址,其值域必须在[0, n-1]。
-
哈希函数计算出的存储位置能够均匀分布在空间内。
-
哈希函数比较简单。
2.3.2 常见的哈希函数
- 直接定址法
此处哈希函数一般为线性函数,hash(key) = A*key + B。
优点:计算简单,不会产生冲突。
缺点:需要事先知道数据的分布范围情况,若分布不连续,会造成内存空间大量浪费。
适用场景:查找数据范围比较小且连续的情况。
- 除留余数法
hash(key) = key % size。
优点:计算简单,适用于数据范围较广,是一种常见的哈希函数。
缺点:哈希冲突。 适用场景:整数的求模运算(int->存储位置)。
💡Tips:哈希函数设计的越精妙,哈希冲突效率就越低,搜索效率就越高,但仍无法避免哈希冲突。
2.4 解决哈希冲突的方法
2.4.1 闭散列
概念:闭散列,也称为开放定址法。若哈希表中未被装满,说明哈希表中还存在"空位置", 就可以把key放到冲突位置的下一个"空位置"处。
缺点:空间利用率较低,这也是哈希的缺陷。
- 问:如何找下一个空位置妮?
- 答:线性探测、二次探测等。
2.4.1.1 线性探测
概念:从冲突位置开始,依次往后进行探测,若探测到哈希表结尾位置,从头开始探测,直到找到下一个空位置为止。hash(key) = key%size + i(i>=0)。
缺点:一旦发生哈希冲突,所以的冲突堆积在一起,就会造成"数据堆积",各个数据相互影响,如同"恶性循环",即:每个关键码占据了可利用的空位置,使得找寻某个关键码时,不能直接找到,需要进行多次比较,搜索效率降低。
2.4.1.2 二次探测
概念:hash(key) = key%size + i^2(i>=0)。
2.4.2 开散列
概念:开散列,也称为开散列拉链法(开链法)、开散列哈希桶。首先先通过哈希函数计算出key在哈希表中的地址,将具有相同关键码key的元素归于同一个子集中,每个子集代表着一个桶,桶中的元素通过单链表连接起来,链表的头节点就存在哈希表中。
2.4.3 负载因子
概念:负载因子:也称为载荷因子,n = 实际存储的数据个数 / size。
负载因子越大,哈希冲突就越高,搜索效率就越低,空间利用率就越高。
对于闭散列,负载因子要控制在0.7~0.8以下,超过0.8,cpu缓存不命中按照指数曲线上升。
2.4.4 开散列与闭散列的比较
-
应用链地址法处理哈希冲突时,要增加链接的指针,似乎增加了存储开销。而开地址法必须保持大量空间空闲,以确保搜索效率,如:二次探测的负载因子<=0.7,而表所占的空间比指针大,所以使用开地址法反而比链地址法更节省空间。
-
闭散列负载因子到了0.7就需要扩容了,开散列负载因子到1就需要扩容了。
2.5 模拟实现
2.5.1 非整形类型转化为整数
-
哈希结构中,计算key所对应的存储位置需要用到求模运算%,但%两操作符必须为整形,对于string、自定义类型不适用,所以我们需要显示写一个仿函数,此仿函数的功能是将任意数据类型转化为整形。只需确保相同的key值转化为整形是唯一的。
-
仿函数hash作用:将各种数据类型K -> int->存储位置, eg : string、Data、Person -> int->存储值。 K类型有两种情况:本身为size_t或者可以强制类型(相近类型)转化为size_t、string或者其他自定义类型。hash默认情况下为第一种,若想要显示控制转化过程,需要自己手动写手动传。
template<class K>
struct HashFunc
{
size_t operator()(const K& key) //size_t、可强制类型转化为size_t
{
return (size_t)key;
}
};
//全特化,特化后若为显示传模板参数,默认情况下会去调用全特化,必须需要一个模板作为基础
template<> //因为string为常见类型,所以将其进行特化
{
size_t operator()(const string& s)
{
size_t hashi = 0;
for (auto& e : s)
{
hashi += e;
hashi *= 131; //BKDRhash算法,哈希冲突小,将字符串转化为整形
}
return hashi;
}
};
- BKDRHash算法是由Brian Kernighan与Dennis Ritchie的《The C Programming Language》一书被展示而得名,是一种简单快捷的hash算法,也是Java目前采用的字符串的Hash算法(累乘因子为31)。BKDRHash算法的原理是将字符串转化为一个整数,然后通过一系列位运算和取模运算,将整数压缩到一个固定范围内的值,最终得到哈希值。
struct HashFunPerson //Person
{
size_t operator()(const Person& p)
{
size_t hashi = 0;
hashi += p._id;
hashi *= 131;
return hashi;
}
};
struct Person
{
string _name;
size_t _id; //身份证号码,唯一
size_t age;
};
struct HashFunPerson //Person
{
size_t operator()(const Person& p)
{
size_t hashi = 0;
hashi += p._id;
hashi *= 131;
return hashi;
}
};
struct Data
{
size_t _year;
size_t _month;
size_t _day;
};
struct HashFunDate //Data
{
size_t operator()(const Data& d)
{
size_t hashi = 0;
hashi += d._year;
hashi *= 131;
hashi += d._month;
hashi *= 131;
hashi += d._day;
hashi *= 131;
return hashi;
}
};
2.5.2 哈希表—闭散列模拟实现
2.5.2.1 哈希表结构的定义
enum State //状态
{
Empty,
Exist,
Delete
};
template<class K, class V>
struct HashData{
pair<K, V> _kv; //数据值
State _state = Empty; //状态
};
/*注意:仿函数hash作用:将各种数据类型K -> int->存储位置, eg : string、Data、Person -> int->存储值
K类型有两种情况:本身为size_t或者可以强制类型(相近类型)转化为size_t、string或者其他自定义类型
hash默认情况下为第一种,若想要显示控制转化过程,需要自己手动写手动传*/
template<class K, class V, class Hash = HashFunc<K>>
class HashTable{
public:
HashTable(size_t n = 10) //构造函数
{
_table.resize(n);
}
private:
vector<HashData<K, V>> _table; //哈希表的物理结构为数组 ——》指针数组
size_t _n = 0; //实际存储的数据个数
};
2.5.2.2 查询
HashData<K, V>* find(const K& key) //查找
{
Hash hs; //仿函数类创建对象,对象调用operator()进行转化为整形
size_t hashi = hs(key) % _table.size(); //key在哈希表中的位置
while (_table[hashi]._state != Empty) //直到遇到空,查找结束
{
if (_table[hashi]._kv.first == key && _table[hashi]._state == Exist)
return &_table[hashi]; //找到了
hashi++; //存在和删除状态继续线性向后查找
hashi = hashi % _table.size(); //走到了哈希表的结尾,从头查找
}
return nullptr; //找不到
}
2.5.2.3 插入
bool insert(const pair<K, V>& kv) //插入
{
Hash hs;
if (find(kv.first)) return false; //unordered_map、unordered_set中key不能重复、
if ((double)_n / _table.size() >= 0.7) //负载因子>=0.7,进行扩容
{
//1.创建新表vector<HashData<K, V>> newtable(_table.size()*2);
//2.遍历旧表,重新映射到新表 -> 冗余
//3.新旧表交换_table.swap(newtable);
HashTable<K, V, Hash> newHT(_table.size() * 2);
for (auto& e : _table) //遍历旧表,重新映射到新表
{
if (e._state == Exist)
newHT.insert(e._kv); //递归,实现代码复用
}
_table.swap(newHT._table);
}
//关键码与存储位置的映射
size_t hashi = hs(kv.first) % _table.size(); //注意:%左右操作符必须为整数
while (_table[hashi]._state == Exist) //发生哈希冲突,线性往后找"空",进行插入
{
hashi++;
hashi = hashi % _table.size();
}
_table[hashi]._kv = kv;
_table[hashi]._state = Exist;
_n++;
return true;
}
2.5.2.4 删除
bool erase(const K& key) //删除 不能直接删除该位置上的值,会影响其他关键码的删除,用状态来标记
{
//查找到了,再进行删除
HashData<K, V>* ret = find(key);
if (ret)
{
ret->_state = Delete;
_n--;
return true;
}
else
return false;
}
2.5.3 哈希桶—开散列模拟实现
2.5.3.1 哈希表结构的定义
template<class K, class V>
struct HashNode {
typedef HashNode<K, V> Node;
Node* _next; //单链表
pair<K, V> _kv;
HashNode(const pair<K, V>& kv)
:_kv(kv)
,_next(nullptr)
{ }
};
template<class K, class V, class Hash = HashFunc<K>>
class HashTable{ //开散列拉链法、开散列哈希桶
public:
typedef HashNode<K, V> Node;
HashTable() //构造函数
{
_table.resize(10, nullptr);
}
~HashTable() //析构函数 ——》 对象中进行了资源申请,需要显示写
{
for (int i = 0; i < _table.size(); i++)
{
Node* next = nullptr;
Node* cur = _table[i];
while (cur) //释放单链表
{
next = cur->_next;
delete cur;
cur = next;
}
_table[i] = nullptr;
}
}
private: //vector<list<K, V>> _table结构也可以,但带头双向循环链表空间开销大
vector<Node*> _table; //哈希表,里面存储的是单链表的头节点
size_t _n = 0; //实际存储的数据个数
};
2.5.3.2 查询
Node* find(const K& key) //查找
{
Hash hs;
size_t hashi = hs(key) % _table.size();
Node* cur = _table[hashi]; //key所对应的桶
while (cur) //遍历桶中的单链表
{
if (cur->_kv.first == key)
return cur; //找到了
cur = cur->_next;
}
return nullptr; //没找到
}
- 先使用哈希函数将key转化为哈希地址,找到对应的桶后,从前往后遍历单链表,直到单链表为空 或者 找到了。
2.5.3.3 插入
bool insert(const pair<K, V>& kv) //插入 本质:开空间,添加新节点
{
if (find(kv.first)) return false; //key是唯一的
//最好情况:每个桶下面只有一个元素
if (_n == _table.size()) //扩容
{
vector<Node*> _newtable(_n * 2, nullptr); //开辟新的哈希表
//取出旧表中每个桶中的单链表上节点,重新计算(映射),链接到新表中,头插
for (size_t i = 0; i < _table.size(); i++)
{
Node* next = nullptr;
Node* cur = _table[i];
while (cur)
{
next = cur->_next;
cur->_next = _newtable[i];
_newtable[i] = cur;
cur = next;
}
_table[i] = nullptr;
}
_table.swap(_newtable); //新旧表交换
}
Hash hs;
size_t hashi = hs(kv.first) % _table.size(); //起始size=10
Node* newnode = new Node(kv);
newnode->_next = _table[hashi];
_table[hashi] = newnode;
_n++;
return true;
}
-
先使用哈希函数将key转化为哈希地址,找到对应的桶后,头插。若表中存在待插入元素,则插入失败,因为unordered_map、unordered_set中的key是唯一的。
-
开散列扩容:存储的元素个数等于桶的个数时,需要扩容。因为哈希表中桶的个数是一定的,随着元素的不断的插入,桶中的元素个数不断增加,再极端情况下,一个桶中有很多很多节点,导致查找性能降低,最好的情况是每个桶中只挂一个节点,每插入一次,就会发生哈希冲突,此时需要进行扩容。
2.5.3.4 删除
bool erase(const K& key) //删除
{
Hash hs;
size_t hashi = hs(key) % _table.size();
Node* prev = nullptr; //单链表的删除需要记录前一个节点,否则会找不到当前节点的下一个
Node* cur = _table[hashi];
while (cur)
{
if (cur->_kv.first == key)
{
if (prev != nullptr) //中间以及后面位置的删除
prev->_next = cur->_next;
else //头删
_table[hashi] = cur->_next;
delete cur; //删除
cur = nullptr;
_n--;
return true;
}
prev = cur;
cur = cur->_next;
}
return false; //key不存在
}
- 先使用哈希函数将key转化为哈希地址,找到对应的桶后,从前往后遍历单链表,直到单链表为空 或者找到了,找到了才能进行删除,但不能直接使用find函数,因为find函数只返回表中要删除元素的地址,而单链表的删除需要记录删除节点的前一个节点,让前一个结点指向删除节点的下一个节点。
3. 哈希表封装unorered_map、unordered_set
- unordered_map、unordered_set共用同一个哈希表,所以将哈希表变为模板。因为与map、set用法上基本上无区别,所以两者的实现基本相同。
3.1 哈希表的模拟实现
3.1.1 迭代器
template<class K, class T, class KeyOfT, class Hash> // 注意 : 前置声明
class HashTable; //类模板的声明必须带上模板参数
template<class K, class T, class KeyOfT, class Hash>
struct Hs_iterator { //迭代器
typedef HashNode<T> Node;
typedef HashTable<K, T, KeyOfT, Hash> HT;
typedef Hs_iterator<K, T, KeyOfT, Hash> Self;
Node* _node; //节点的地址 -》可实现*、!=、==、->
HT* _hs; //对象的地址 -》可实现++,为了找到下一个非空桶方便
};
3.1.1.1 构造函数
Hs_iterator(Node* node, HT* hs) //构造函数
:_node(node)
,_hs(hs)
{ }
3.1.1.2 begin()+end()
💡iterator begin( ) ;
- 功能:返回哈希表中第一个非空桶的第一个节点的迭代器
iterator begin() //哈希表中第一个非空桶的第一个位置
{
for (size_t i = 0; i < _table.size(); i++)
{
if (_table[i])
{
return iterator(_table[i], this);
}
}
return end(); //哈希表中全为空桶
}
💡iterator end( ) ;
- 功能:返回空指针。
iterator end()
{
return iterator(nullptr, this);
}
3.1.1.3 operator++()
//对于++,走到某个桶的结束位置,需要找下一个非空桶,此时需要借助_table数组
Self& operator++()
{
KeyOfT kt;
Hash ht;
if (_node->_next) //当前桶还有数据,直接取当前迭代器所指向节点的下一个节点
_node = _node->_next;
else //当前桶走完了,需要找下一个非空桶的第一个节点
{
size_t hashi = ht(kt(_node->_kv)) % _hs->_table.size();
hashi++;
while (hashi < _hs->_table.size())
{
if (_hs->_table[hashi]) //找到了
{
_node = _hs->_table[hashi];
break;
}
hashi++;
}
if (hashi == _hs->_table.size()) //不存在下一个非空桶
_node = nullptr;
}
return *this;
}
- 如果当前桶还有数据,直接取当前迭代器所指向节点的下一个节点 ; 如果当前桶走完了,需要找下一个非空桶的第一个节点。此时需要借助_table。
3.1.1.4 operator*()
T& operator*() //解引用
{
return _node->_kv;
}
3.1.1.5 operator->()
T* operator->() //结构体指针
{
return &_node->_kv;
}
3.1.1.6 operator==()
bool operator==(const Self& it)
{
return _node == it._node;
}
3.1.1.7 operator!=()
bool operator!=(const Self& it)
{
return _node != it._node;
}
3.1.2 insert()
💡pair<iterator,bool> insert(const T& kv) ;
- 功能:向红黑树中插入data。
- insert返回值为pair<iterator, bool>,若key(unordered_set的key、unordered_map的pair的first)在哈希表中存在,因为键值key不能重复,所以pair::first指向在哈希表中与key值相等节点的迭代器,pair::second为false。若key在哈希表中不存在,pair::first指向在哈希表中新插入节点的迭代器,pair::second为true。insert相当于查找。
pair<iterator, bool> insert(const T& kv) //插入 本质:开空间,添加新节点
{
KeyOfT kot;
iterator ret = find(kot(kv));
if (ret != end()) return make_pair(ret, false); //key是唯一的 插入失败,返回该节点在哈希表的位置(迭代器)
//最好情况:每个桶下面只有一个元素
if(_n == _table.size()) //负载因子为1,扩容
{
vector<Node*> _newtable(_n * 2, nullptr); //开辟新的哈希表
// 取出旧表中每个桶中的单链表上节点,重新计算(映射),链接到新表中,头插
for (size_t i = 0; i < _table.size(); i++)
{
Node* next = nullptr;
Node* cur = _table[i];
while (cur)
{
next = cur->_next;
cur->_next = _newtable[i];
_newtable[i] = cur;
cur = next;
}
_table[i] = nullptr;
}
_table.swap(_newtable); //新旧表交换
}
Hash ht;
size_t hashi = ht(kot(kv)) % _table.size(); //起始size=10
Node* newnode = new Node(kv);
newnode->_next = _table[hashi];
_table[hashi] = newnode;
_n++;
return make_pair(iterator(newnode, this), true);
}
3.1.3 完整代码
/*注意:仿函数hash作用:将各种数据类型K -> int->存储位置, eg : string、Data、Person -> int->存储值
K类型有两种情况:本身为size_t或者可以强制类型(相近类型)转化为size_t、string或者其他自定义类型
hash默认情况下为第一种,若想要显示控制转化过程,需要自己手动写手动传*/
template<class K, class T, class KeyOfT, class Hash> //KeyOfT:取出T中的第一个值
class HashTable { //开散列拉链法、开散列哈希桶
public:
//在迭代器++中,使用了private成员_table,在类外不能访问私有成员,若想被访问,则设置成友元
template<class K, class T, class KeyOfT, class Hash>
friend struct Hs_iterator; //将类模板设置为友元类,需要加上模板参数
typedef HashNode<T> Node;
typedef HashTable<K, T, KeyOfT, Hash> HT;
typedef Hs_iterator<K, T, KeyOfT, Hash> iterator;
iterator begin() //哈希表中第一个非空桶的第一个位置
{
for (size_t i = 0; i < _table.size(); i++)
{
if (_table[i])
{
return iterator(_table[i], this);
}
}
return end(); //哈希表中全为空桶
}
iterator end()
{
return iterator(nullptr, this);
}
HashTable() //构造函数
{
_table.resize(10, nullptr);
}
HashTable(const HT& ht) //拷贝构造函数
{
_table.resize(10, nullptr); //开空间
for (int i = 0; i < ht.size(); i++) //拷贝数据
{
if (ht._table[i])
insert(ht._table[i]->_kv);
}
}
HT& operator=(HT ht) //赋值运算符重载
{
_table.swap(ht._table);
swap(_n, ht._n);
return *this;
}
~HashTable() //析构函数 ——》 对象中进行了资源申请,需要显示写
{
for (int i = 0; i < _table.size(); i++)
{
Node* next = nullptr;
Node* cur = _table[i];
while (cur) //释放单链表
{
next = cur->_next;
delete cur;
cur = next;
}
_table[i] = nullptr;
}
}
iterator find(const K& key) //查找
{
Hash ht;
KeyOfT kot;
size_t hashi = ht(key) % _table.size();
Node* cur = _table[hashi]; //key所对应的桶
while (cur) //遍历桶中的单链表
{
if (kot(cur->_kv) == key)
return iterator(cur, this); //找到了
cur = cur->_next;
}
return end(); //没找到
}
pair<iterator, bool> insert(const T& kv) //插入 本质:开空间,添加新节点
{
KeyOfT kot;
iterator ret = find(kot(kv));
if (ret != end()) return make_pair(ret, false); //key是唯一的 插入失败,返回该节点在哈希表的位置(迭代器)
//最好情况:每个桶下面只有一个元素
if(_n == _table.size()) //负载因子为1,扩容
{
vector<Node*> _newtable(_n * 2, nullptr); //开辟新的哈希表
// 取出旧表中每个桶中的单链表上节点,重新计算(映射),链接到新表中,头插
for (size_t i = 0; i < _table.size(); i++)
{
Node* next = nullptr;
Node* cur = _table[i];
while (cur)
{
next = cur->_next;
cur->_next = _newtable[i];
_newtable[i] = cur;
cur = next;
}
_table[i] = nullptr;
}
_table.swap(_newtable); //新旧表交换
}
Hash ht;
size_t hashi = ht(kot(kv)) % _table.size(); //起始size=10
Node* newnode = new Node(kv);
newnode->_next = _table[hashi];
_table[hashi] = newnode;
_n++;
return make_pair(iterator(newnode, this), true);
}
bool erase(const K& key) //删除
{
Hash _ht;
KeyOfT kot;
size_t hashi = _ht(key) % _table.size();
Node* prev = nullptr; //单链表的删除需要记录前一个节点
Node* cur = _table[hashi];
while (cur)
{
if (kot(cur->_kv) == key)
{
if (prev != nullptr) //中间以及后面位置的删除
prev->_next = cur->_next;
else //头删
_table[hashi] = cur->_next;
delete cur; //删除
cur = nullptr;
_n--;
return true;
}
prev = cur;
cur = cur->_next;
}
return false; //key不存在
}
private:
vector<Node*> _table; //哈希表,里面存储的是单链表的头节点 ——》指针数组
size_t _n = 0; //实际存储的数据个数
};
4.1 unorered_set的模拟实现
4.1.1 完整代码
#define _CRT_SECURE_NO_WARNINGS 1
#include"HashTable.h"
namespace zzx {
template<class K, class Hash = HashFunc<K>>
class unordered_set {
public:
struct SetKeyOfT {
const K& operator()(const K& key)
{
return key;
}
};
//typename作用:区分类域中的静态成员变量和typedef类型
typedef typename HashTable<K, K, SetKeyOfT, Hash>::iterator iterator;
iterator find(const K& key)
{
return _hs.find(key);
}
pair<iterator, bool> insert(const K& key)
{
return _hs.insert(key);
}
bool erase(const K& key)
{
return _hs.erase(key);
}
iterator begin()
{
return _hs.begin();
}
iterator end()
{
return _hs.end();
}
private:
HashTable<K, K, SetKeyOfT, Hash> _hs;
};
}
5.1 unorered_map的模拟实现
5.1.1 operator[]
💡V& operator[ ](const K& key) ;
-
功能:访问与key相对应的value值。即可读又可写。
-
原理:operator[ ]底层是通过调用insert( )将键值队插入到unordered_map中。如果key存在,插入失败,insert返回与unordered_map中key值相同元素的迭代器。如果key不存在,插入成功,insert返回在unordered_map中新插入元素的迭代器。operator[ ]最后返回与key值相对应的value值的引用。
-
operator[ ] 具有插入、查找、插入+修改、查找+修改功能。
V& operator[](const K& key)
{
pair<iterator, bool> ret = insert(make_pair(key, V()));
return ret.first->second;
}
5.1.2 完整代码
#define _CRT_SECURE_NO_WARNINGS 1
#include"HashTable.h"
namespace zzx {
template<class K, class V, class Hash = HashFunc<K>>
class unordered_map {
public:
struct MapKeyOfT {
const K& operator()(const pair<K, V>& kv)
{
return kv.first;
}
};
typedef typename HashTable<K, pair<K, V>, MapKeyOfT, Hash>::iterator iterator;
iterator find(const K& key)
{
return _hs.find(key);
}
pair<iterator, bool> insert(const pair<K, V>& kv)
{
return _hs.insert(kv);
}
V& operator[](const K& key)
{
pair<iterator, bool> ret = insert(make_pair(key, V()));
return ret.first->second;
}
bool erase(const K& key)
{
return _hs.erase(key);
}
iterator begin()
{
return _hs.begin();
}
iterator end()
{
return _hs.end();
}
private:
HashTable<K, pair<K, V>, MapKeyOfT, Hash> _hs;
};
}