cpp►STL容器-＞排序容器-＞map

Posted 2021-06-30 itzyjr

目录

• • • • • • 描述
          • 容器属性(Container properties)
          • 成员类型(Member types)
          • 成员函数(Member functions)
          • 观察者(Observers)

描述

std::map

template <class Key, class T, class Compare = less<Key>,
          class Alloc = allocator<pair<const Key, T>>>
class map;

map是关联容器，用于存储由key-value键值对组合而成的元素，并遵循特定顺序。

在map中，key值通常用于对元素进行排序和唯一标识，而映射的value存储与该key关联的内容。key和value的类型可能不同，并通过成员类型value_type组合在一起，这是一种结合了以下两者的pair类型：typedef pair<const Key, T> value_type;

在内部，map中的元素总是按照其内部比较对象(Compare类型)指示的特定严格弱排序标准，按其key进行排序。

map通常比unordered_map通过其key访问单个元素的速度慢，但是它们允许基于其顺序对子集进行直接迭代。

map中的映射值可以使用括号运算符(operator[])通过相应的key直接访问。

map通常作为二进制搜索树的典型实现。

容器属性(Container properties)

• Associative
  关联容器中的元素由其key引用，而不是由其在容器中的绝对位置引用。
• Ordered
  容器中的元素始终遵循严格的顺序。所有插入的元素都按此顺序给定一个位置。
• Map
  每个元素都将一个key与一个value相关联：key用于标识其主要内容是value的元素。
• Unique keys
  容器中的任何两个元素都不能有相等的key。
• Allocator-aware
  容器使用分配器对象动态处理其存储需求。

成员类型(Member types)

成员类型	定义	备注
key_type	第一个模板参数(Key)
mapped_type	第二个模板参数(T)
value_type	pair<const key_type, mapped_type>
key_compare	每三个模板参数(Compare)	默认为：less<key_type>
value_compare	用于比较元素的嵌套函数类	参见：value_comp
iterator	一个针对value_type的双向迭代器	可转换为常量迭代器

成员函数(Member functions)

构造函数：

// constructing maps
#include <iostream>
#include <map>
bool fncomp(char lhs, char rhs) { 
	return lhs < rhs; 
}
struct classcomp {
	bool operator() (const char& lhs, const char& rhs) const {
		return lhs < rhs;
	}
};
int main() {
	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;
}

观察者(Observers)

• key_comp
• value_comp
  value_compare value_comp() const;
  返回的比较对象是成员类型map::value_compare的对象，它是一个嵌套类，使用内部比较对象生成适当的比较函数类。其定义与以下行为相同：

template <class Key, class T, class Compare, class Alloc>
class map<Key, T, Compare, Alloc>::value_compare {
	friend class map;
protected:
	Compare comp;
	value_compare(Compare c) : comp(c) {}  // constructed with map's comparison object
public:
	typedef bool result_type;
	typedef value_type first_argument_type;
	typedef value_type second_argument_type;
	bool operator() (const value_type& x, const value_type& y) const {
		return comp(x.first, y.first);
	}
}

// map::value_comp
#include <iostream>
#include <map>
int main() {
	std::map<char, int> mymap;
	mymap['x'] = 1001;
	mymap['y'] = 2002;
	mymap['z'] = 3003;
	std::cout << "mymap contains:\\n";
	std::pair<char, int> highest = *mymap.rbegin();// last element

	std::map<char, int>::iterator it = mymap.begin();
	do {
		std::cout << it->first << " => " << it->second << '\\n';
	} while (mymap.value_comp()(*it++, highest));
	return 0;
}

mymap contains:
x => 1001
y => 2002
z => 3003