std::map(转)
1. std::map 的定义与特性
所在头文件：<map>
std::map 类模板：
template < class Key, // map::key_type
class T, // map::mapped_type
class Compare = less<Key>, // map::key_compare
class Alloc = allocator<pair<const Key,T> > // map::allocator_type
> class map;
1
2
3
4
5
在 std::map 中，Key 和 T 一起组成了 std::map 的 value_type：
typedef pair<const Key, T> value_type;
1
一些类型定义：
类型成员 定义
key_type 第一个模板参数（Key）
mapped_type 第二个模板参数（T）
value_type pair<const key_type,mapped_type>
key_compare 第三个模板参数（Compare）
关联性：std::map 是一个关联容器，其中的元素根据键来引用，而不是根据索引来引用。
有序性：在内部，std::map 中的元素总是按照其内部的比较器（比较器类型由Compare类型参数指定）指示的特定严格弱序标准按其键排序。
唯一性：std::map 中的元素的键是唯一的。
std::map 通常由二叉搜索树实现。
2. 构造 std::map
构造方式 函数声明
构造空map explicit map (const key_compare& comp = key_compare(),
const allocator_type& alloc = allocator_type());
explicit map (const allocator_type& alloc);
由一对范围迭代器指定输入 template <class InputIterator>
map (InputIterator first, InputIterator last,
const key_compare& comp = key_compare(),
const allocator_type& = allocator_type());
复制构造 map (const map& x);
map (const map& x, const allocator_type& alloc);
移动构造 map (map&& x);
map (map&& x, const allocator_type& alloc);
利用初始化列表构造 map (initializer_list<value_type> il,
const key_compare& comp = key_compare(),
const allocator_type& alloc = allocator_type());
例子：
// constructing maps
#include <iostream>
#include <map>
// 比较器1
bool fncomp (char lhs, char rhs) {
return lhs < rhs;
}
// 比较器2
struct classcomp {
bool operator() (const char& lhs, const char& rhs) const {
return lhs<rhs;
}
};
int main () {
// 默认构造，构造一个空的map
std::map<char,int> first;
first['a']=10;
first['b']=30;
first['c']=50;
first['d']=70;
// 由一对范围迭代器指定输入
std::map<char,int> second (first.begin(), first.end());
// 复制构造
std::map<char,int> third (second);
// 指定比较器：使用类
std::map<char, int, classcomp> fourth; // class as Compare
// 指定比较器：使用函数指针
bool(*fn_pt)(char, char) = fncomp;
std::map<char, int, bool(*)(char,char)> fifth (fn_pt); // function pointer as Compare
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
3. 赋值操作
赋值方式 函数声明
复制 map& operator= (const map& x);
移动 map& operator= (map&& x);
初始化列表 map& operator= (initializer_list<value_type> il);
4. 迭代器操作
函数声明 解释 返回值类型
begin() 返回一个迭代器，指向第一个元素 iterator 或 const_iterator
end() 返回一个迭代器，指向尾后元素 iterator 或 const_iterator
rbegin() 返回一个反向迭代器，指向最后一个元素 reverse_iterator 或 const_reverse_iterator
rend() 返回一个反向迭代器，指向第一个元素之前虚拟的元素 reverse_iterator 或 const_reverse_iterator
cbegin() 返回一个常量迭代器，指向第一个元素 const_iterator
cend() 返回一个常量迭代器，指向尾后元素 const_iterator
crbegin() 返回一个常量反向迭代器，指向最后一个元素 const_reverse_iterator
crend() 返回一个常量反向迭代器，指向第一个元素之前虚拟的元素 const_reverse_iterator
5. 容量操作
函数声明 解释
bool empty() const noexcept; map 是否为空
size_type size() const noexcept; 获取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::map 不能使用 operator[] 操作！！
7. 插入操作
插入方式 函数声明 说明
插入单个元素 pair<iterator,bool> insert (const value_type& val);
template <class P>
pair<iterator,bool> insert (P&& val); // 类型P应当可以转换为 value_type类型 返回一个pair，其中第一个值为一个迭代器，指向新插入的元素或其键等于待插入元素的键的元素（原先就已存在的元素）；第二个值是一个bool值，当插入一个新元素时，该值设为true，当该键已存在时，该值设为false
带插入位置提示 iterator insert (const_iterator position, const value_type& val);
template <class P>
iterator insert (const_iterator position, P&& val); 返回一个迭代器，该迭代器指向新插入的元素或指向键相等的已存在元素。
由一对范围迭代器指定输入 template <class InputIterator>
void insert (InputIterator first, InputIterator last);
使用初始化列表指定插入元素 void insert (initializer_list<value_type> il);
例子：
// map::insert (C++98)
#include <iostream>
#include <map>
int main () {
std::map<char, int> mymap;
// 插入单个元素
mymap.insert ( std::pair<char,int>('a',100) );
mymap.insert ( std::pair<char,int>('z',200) );
std::pair<std::map<char,int>::iterator,bool> ret;
ret = mymap.insert ( std::pair<char,int>('z',500) );
if (ret.second==false) {
std::cout << "element 'z' already existed";
std::cout << " with a value of " << ret.first->second << '\n';
}
// 带插入位置提示，只是提示，并不强制插入此位置
std::map<char,int>::iterator it = mymap.begin();
mymap.insert (it, std::pair<char,int>('b',300)); // max efficiency inserting
mymap.insert (it, std::pair<char,int>('c',400)); // no max efficiency inserting
// 由一对范围迭代器指定输入
std::map<char,int> anothermap;
anothermap.insert(mymap.begin(), mymap.find('c'));
// 打印内容
std::cout << "mymap contains:\n";
for (it=mymap.begin(); it!=mymap.end(); ++it)
std::cout << it->first << " => " << it->second << '\n';
std::cout << "anothermap contains:\n";
for (it=anothermap.begin(); it!=anothermap.end(); ++it)
std::cout << it->first << " => " << it->second << '\n';
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
8. 删除操作
删除方式 函数声明 说明
根据元素位置 iterator erase (const_iterator position); 返回一个迭代器，指向被删除元素的后一个元素
根据元素的键 size_type erase (const key_type& k); 返回被删除元素的数目，此处为1
由一对范围迭代器指定删除的范围 iterator erase (const_iterator first, const_iterator last); 返回一个迭代器，指向最后一个被删除元素的后一个元素
删除所有元素 void clear() noexcept;
例子：
// erasing from map
#include <iostream>
#include <map>
int main () {
std::map<char,int> mymap;
std::map<char,int>::iterator it;
// insert some values:
mymap['a']=10;
mymap['b']=20;
mymap['c']=30;
mymap['d']=40;
mymap['e']=50;
mymap['f']=60;
it=mymap.find('b');
mymap.erase (it); // 删除迭代器指向的元素
mymap.erase ('c'); // 删除相应键值的元素
it=mymap.find ('e');
mymap.erase ( it, mymap.end() ); // 删除一个范围内的所有元素
// show content:
for (it=mymap.begin(); it!=mymap.end(); ++it)
std::cout << it->first << " => " << it->second << '\n';
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
9. 查找操作
函数声明 说明
iterator find (const key_type& k);
const_iterator find (const key_type& k) const; 在容器中搜索键值等于 k 的元素，如果找到，则返回一个指向该元素的迭代器，否则返回一个指向map :: end的迭代器。
例子：
// map::find
#include <iostream>
#include <map>
int main () {
std::map<char,int> mymap;
std::map<char,int>::iterator it;
mymap['a']=50;
mymap['b']=100;
mymap['c']=150;
mymap['d']=200;
// 查找
it = mymap.find('b');
if (it != mymap.end())
mymap.erase (it);
// print content:
std::cout << "elements in mymap:" << '\n';
std::cout << "a => " << mymap.find('a')->second << '\n';
std::cout << "c => " << mymap.find('c')->second << '\n';
std::cout << "d => " << mymap.find('d')->second << '\n';
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
10. 范围查询操作
函数声明 说明
iterator lower_bound (const key_type& k);
const_iterator lower_bound (const key_type& k) const; 返回一个迭代器，指向容器中第一个键值等于 k 或排在 k 之后的元素
iterator upper_bound (const key_type& k);
const_iterator upper_bound (const key_type& k) const; 返回一个迭代器，指向容器中第一个键值排在 k 之后的元素
pair<const_iterator,const_iterator> equal_range (const key_type& k) const;
pair<iterator,iterator> equal_range (const key_type& k); 返回一对迭代器，该范围内的所有元素的键值等于 k，当然，此处只包含一个元素。
如果找不到键值与 k 相等的元素，则两个迭代器均指向排在 k 之后的第一个元素。
例子：
// map::lower_bound/upper_bound
#include <iostream>
#include <map>
int main () {
std::map<char,int> mymap;
std::map<char,int>::iterator itlow,itup;
mymap['a']=20;
mymap['b']=40;
mymap['c']=60;
mymap['d']=80;
mymap['e']=100;
itlow=mymap.lower_bound ('b'); // itlow points to b：等于或大于'b'
itup=mymap.upper_bound ('d'); // itup points to e (not d!)：大于'd'
mymap.erase(itlow,itup); // erases [itlow,itup)
// print content:
for (std::map<char,int>::iterator it=mymap.begin(); it!=mymap.end(); ++it)
std::cout << it->first << " => " << it->second << '\n';
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
参考：http://www.cplusplus.com/reference/map/map/
————————————————
版权声明：本文为CSDN博主「W.T.F.」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/fcku_88/article/details/88135150
浙公网安备 33010602011771号