C++ std::map 用法详解

1. std::map 的定义与特性

• 所在头文件：

• std::map 类模板：

  template < class Key,                                     // map::key_type
             class T,                                       // map::mapped_type
             class Compare = less,                     // map::key_compare
             class Alloc = allocator >    // map::allocator_type
             > class map;
  

  • 在 std::map 中，Key 和 T 一起组成了 std::map 的 value_type：

    typedef pair<const Key, T> value_type;
    

  • 一些类型定义：

  类型成员	定义
  key_type	第一个模板参数（Key）
  mapped_type	第二个模板参数（T）
  value_type	pair
  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 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 il,          const key_compare& comp = key_compare(),          const allocator_type& alloc = allocator_type());

例子：

// constructing maps
#include 
#include 

// 比较器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;
}

3. 赋值操作

赋值方式	函数声明
复制	map& operator= (const map& x);
移动	map& operator= (map&& x);
初始化列表	map& operator= (initializer_list 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 insert (const value_type& val); template pair insert (P&& val); // 类型P应当可以转换为 value_type类型	返回一个pair，其中第一个值为一个迭代器，指向新插入的元素或其键等于待插入元素的键的元素（原先就已存在的元素）；第二个值是一个bool值，当插入一个新元素时，该值设为true，当该键已存在时，该值设为false
带插入位置提示	iterator insert (const_iterator position, const value_type& val); template iterator insert (const_iterator position, P&& val);	返回一个迭代器，该迭代器指向新插入的元素或指向键相等的已存在元素。
由一对范围迭代器指定输入	template void insert (InputIterator first, InputIterator last);
使用初始化列表指定插入元素	void insert (initializer_list il);

例子：

// map::insert (C++98)
#include 
#include 

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;
}

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 
#include 

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;
}

9. 查找操作

函数声明	说明
iterator find (const key_type& k); const_iterator find (const key_type& k) const;	在容器中搜索键值等于 k 的元素，如果找到，则返回一个指向该元素的迭代器，否则返回一个指向map :: end的迭代器。

例子：

// map::find
#include 
#include 

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;
}

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 equal_range (const key_type& k) const; pair equal_range (const key_type& k);	返回一对迭代器，该范围内的所有元素的键值等于 k，当然，此处只包含一个元素。 如果找不到键值与 k 相等的元素，则两个迭代器均指向排在 k 之后的第一个元素。

例子：

// map::lower_bound/upper_bound
#include 
#include 

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;
}

参考：http://www.cplusplus.com/reference/map/map/