C++C--unordered_map常见⽤法详解
⽂章⽬录
1. std::unordered_map 的定义与特性
所在头⽂件：<unordered_map>
std::unorederd_map类模板：
template<class Key,// unordered_map::key_type
class T,// unordered_map::mapped_type
class Hash = hash<Key>,// unordered_map::hasher
class Pred = equal_to<Key>,// unordered_map::key_equal
class Alloc = allocator< pair<const Key,T>>// unordered_map::allocator_type
>class unordered_map;
关联性：std::unorederd_map 是⼀个关联容器，其中的元素根据键来引⽤，⽽不是根据索引来引⽤。
⽆序性：在内部，std::unordered_map中的元素不会根据其键值或映射值按任何特定顺序排序，⽽是根据其哈希值组织到桶中，以允许通过键值直接快速访问各个元素（常量的平均时间复杂度）。
唯⼀性：std::unorederd_map中的元素的键是唯⼀的。
⼀些类型定义：
类型成员定义
key_type第⼀个模板参数（Key）
mapped_type第⼆个模板参数（T）
value_type pair<const key_type,mapped_type>
hasher第三个模板参数（Hash）
key_equal第四个模板参数（Pred）
2. 构造 std::unordered_map
构造⽅式函数声明
构造空的 unordered_map explicit unordered_map ( size_type n = /* see below */,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& alloc = allocator_type() ); explicit unordered_map ( const allocator_type& alloc );
由⼀对范围迭代器指定输⼊template <class InputIterator>
unordered_map(InputIterator first, InputIterator last,
size_type n = /* see below */,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& alloc = allocator_type() );
复制构造unordered_map ( const unordered_map& ump );
unordered_map ( const unordered_map& ump, const allocator_type& alloc );
移动构造
unordered_map ( unordered_map&& ump );
unordered_map ( unordered_map&& ump, const allocator_type& alloc )；利⽤初始化列表构造unordered_map (initializer_list<value_type> il, size_type n = /* see below */,
const hasher& hf = hasher(), const key_equal& eql = key_equal(),
const allocator_type& alloc = allocator_type() );
构造⽅式函数声明
参数解释：
n ： 初始时，桶的最⼩数量，即最少有多少个桶。
hf ： 哈希函数对象。它是⼀个函数，根据传递给它的键计算并返回⼀个整数。eql ： ⽐较函数对象。如果传递给它的两个参数相等，则返回true.例⼦：
// constructing unordered_maps #include <iostream>#include <string>
#include <unordered_map>
typedef std ::unordered_map <std ::string ,std ::string > stringmap ;stringmap merge (stringmap a ,stringmap b ) { stringmap temp (a );
temp .insert (b .begin (),b .end ()); return temp ;}
int main () {
stringmap first ; // empty // ⼀个元素为：{key, value}
stringmap second ( {{"apple","red"}, {"lemon","yellow"}} ); // init list stringmap third ( {{"orange","orange"}, {"strawberry","red"}} ); // init list stringmap fourth (second ); // copy stringmap fifth (merge (third ,fourth )); // move stringmap sixth (fifth .begin (),fifth .end ()); // range
std ::cout << "sixth contains:"<<endl ; for (auto & x : sixth )
std ::cout << x .first << ":" << x .second <<endl ; std ::cout << std ::endl ; system ("pause"); return 0;}
运⾏结果：
3. 赋值操作
赋值⽅式函数声明
复制unordered_map& operator= ( const unordered_map& ump );
移动unordered_map& operator= ( unordered_map&& ump );
初始化列表unordered_map& operator= ( intitializer_list<value_type> il );
例⼦：
// assignment operator with unordered_map
#include<iostream>
#include<string>
#include<unordered_map>
typedef std::unordered_map<std::string, std::string> stringmap;
stringmap merge(stringmap a, stringmap b){
stringmap temp(a);
temp.insert(b.begin(), b.end());
return temp;
}
int main(){
//stringmap first, second, third;//此处连续定义三个会报错。
stringmap first ={{"AAPL","Apple"},{"MSFT","Microsoft"}};// init list
stringmap second ={{"GOOG","Google"},{"ORCL","Oracle"}};// init list
stringmap third =merge(first, second);// move
first = third;// copy
std::cout <<"first contains:"<<std::endl;
for(auto& elem : first)
std::cout << elem.first <<":"<< elem.second<<std::endl;
std::cout << std::endl;
system("pause");
return0;
}
运⾏结果：
4. 迭代器操作
4.1 指向整个容器中的元素
即，“第⼀个”指整个容器中的第⼀个，“尾后”指整个容器中的尾后。
函数声明解释
iterator begin() noexcept;
返回⼀个迭代器，指向第⼀个元素const_iterator begin() const noexcept;
iterator end() noexcept;
返回⼀个迭代器，指向尾后元素const_iterator end() const noexcept;
函数声明解释
const_iterator cbegin() const noexcept；返回⼀个常量迭代器，指向第⼀个元素
const_iterator cend() const noexcept；返回⼀个常量迭代器，指向尾后元素
4.2 指向某个桶中的元素
即，“第⼀个”指某个桶中的第⼀个，“尾后”指某个桶中的尾后。
函数声明解释
local_iterator begin( size_type n );
返回⼀个迭代器，指向第n个桶内的第⼀个元素const_local_iterator begin ( size_type n ) const;
local_iterator end(size_type n);
返回⼀个迭代器，指向第n个桶内的尾后元素
const_local_iterator end (size_type n) const;
const_local_iterator cbegin( size_type n ) const；返回⼀个常量迭代器，指向第n个桶内的第⼀个元素
const_local_iterator cend( size_type n ) const；返回⼀个常量迭代器，指向第n个桶内的尾后元素例⼦：
// unordered_map::cbegin/cend example
#include<iostream>
#include<string>
#include<unordered_map>
int main(){
std::unordered_map<std::string, std::string> mymap={{"Australia","Canberra"},{"U.S.","Washington"},{"France","Paris"}}; std::cout <<"mymap contains:"<<std::endl;
for(auto it = mymap.cbegin(); it != d();++it)
std::cout << it->first <<":"<< it->second<<std::endl;// cannot modify *it
std::cout << std::endl;
std::cout <<"mymap's buckets contain:\n";
for(unsigned i =0; i < mymap.bucket_count();++i){
std::cout <<"bucket #"<< i <<" contains:";
for(auto local_it = mymap.cbegin(i); local_it != d(i);++local_it)
std::cout << local_it->first <<":"<< local_it->second;
std::cout << std::endl;
}
system("pause");
return0;
}
运⾏结果：
5. 容量操作
函数声明
解释
system的头文件bool empty() const noexcept;unordered_map 是否为空
size_type size() const noexcept;
获取unordered_map 中元素的数量
6. 访问操作
访问⽅式
函数声明
解释
使⽤⽅括号（[]）
mapped_type& operator[] (const
key_type& k);
mapped_type& operator[] (key_type&& k)；如果 k 匹配容器中某个元素的键，则该函数返回该映射值的引⽤。
如果 k 与容器中任何元素的键都不匹配，则该函数将使⽤该键插⼊⼀个新元素，并返回该映射值的引⽤。使⽤ at()
mapped_type& at (const key_type& k);
const mapped_type& at (const key_type&k) const；如果 k 匹配容器中某个元素的键，则该函数返回该映射值的引⽤。
如果 k 与容器中任何元素的键都不匹配，则该函数将抛出 out_of_range 异常。
注意：const std::unordered_map 不能使⽤ operator[] 操作！！例⼦：
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论