【深度探索STL】关联式容器map和multimap

最新推荐文章于 2022-08-29 09:45:00 发布

selfimpr1991

最新推荐文章于 2022-08-29 09:45:00 发布

阅读量3.3k

点赞数 1

分类专栏： C/C++ & STL OpenSource 深度探索STL 文章标签： STL map multimap

本文链接：https://blog.csdn.net/wenqian1991/article/details/38435659

版权

OpenSource 同时被 3 个专栏收录

38 篇文章 11 订阅

订阅专栏

C/C++ & STL

29 篇文章 4 订阅

订阅专栏

深度探索STL

13 篇文章 20 订阅

订阅专栏

map与multimap的区别等同于set 与multiset的区别。

一、map

map的特性是，所有元素都会根据元素的键值自动被排序。map中的所有元素都是pair（意味着两个元素），同时拥有实质（value）和键值（key）。pair的第一元素被视为键值，第二元素被视为实质。回忆set，set 中的所有元素都是单个的（实值就是键值，键值就是实值）。map不允许两个元素拥有相同的键值。

下面是pair的定义

template <class T1, class T2>
struct pair {
	typedef T1 first_type;
	typedef T2 second_type;

	T1 first;
	T2 second;
	pair() : first(T1()), second(T2()) {}
	pair(const T1& a, const T2& b) : first(a), second(b) {}

};

从上可以看出，pair 包含两个类型（可以相同，也可以不相同）的公共元素。

map同set一样，都是关联式容器，内部元素的实值都会根据其键值来进行排序（set 的实值就是键值），所以都不能任意改变元素的键值，但是map可以任意改变元素的实值，我们所有操作的前提以及是否被允许，要看是否会影响到map元素的排序规则。

同样map和multimap 也是以RB-tree 为底层机制，几乎所有的map操作行为，都只是转调用RB-tree的操作行为而已。

set 和 map的内部结构即元素的存储都是RB-tree，set 中，RB-tree的节点内容是单一元素，而map中，节点内容则是一个pair（<key，value>）。

class map {
public:

	// typedefs:

	typedef Key key_type; //键值型别
	typedef T data_type;  //实值型别
	typedef pair<const Key, T> value_type;  //元素性别（键值/实值）
	typedef Compare key_compare;  //键值比较函数

	//定义一个函数，其作用就是调用“元素比较函数”
	class value_compare
		: public binary_function<value_type, value_type, bool> {
		friend class map<Key, T, Compare, Alloc>;
	protected:
		Compare comp;
		value_compare(Compare c) : comp(c) {}
	public:
		//重载
		bool operator()(const value_type& x, const value_type& y) const {
			return comp(x.first, y.first);
		}
	};

private:
	typedef rb_tree<key_type, value_type,
		select1st<value_type>, key_compare, Alloc> rep_type;
	rep_type t;  // 以RB-tree为底层实现，所有元素(pair)存放在RB-tree节点中
public:
	//两种类型的都有，因为map允许用户通过迭代器修改元素的实值
	typedef rep_type::pointer pointer;
	typedef rep_type::reference reference;
	typedef rep_type::const_reference const_reference;
	typedef rep_type::iterator iterator;
	typedef rep_type::const_iterator const_iterator;
	typedef rep_type::reverse_iterator reverse_iterator;
	typedef rep_type::const_reverse_iterator const_reverse_iterator;
	typedef rep_type::size_type size_type;
	typedef rep_type::difference_type difference_type;

	// allocation/deallocation
	//构造函数
	map() : t(Compare()) {}
	explicit map(const Compare& comp) : t(comp) {}

	/*map一定使用底层RB-tree 的insert_unique()*/

	map(const map<Key, T, Compare, Alloc>& x) : t(x.t) {}
	map<Key, T, Compare, Alloc>& operator=(const map<Key, T, Compare, Alloc>& x)
	{
		t = x.t;
		return *this;
	}

	// accessors:
	//转调用RB-tree的操作行为
	key_compare key_comp() const { return t.key_comp(); }
	value_compare value_comp() const { return value_compare(t.key_comp()); }
	iterator begin() { return t.begin(); }
	const_iterator begin() const { return t.begin(); }
	iterator end() { return t.end(); }
	const_iterator end() const { return t.end(); }
	reverse_iterator rbegin() { return t.rbegin(); }
	const_reverse_iterator rbegin() const { return t.rbegin(); }
	reverse_iterator rend() { return t.rend(); }
	const_reverse_iterator rend() const { return t.rend(); }
	bool empty() const { return t.empty(); }
	size_type size() const { return t.size(); }
	size_type max_size() const { return t.max_size(); }
	/*下面这个下标操作符重载函数是的map支持元素的直接存取，索引值是元素的key*/
	T& operator[](const key_type& k) 
	{
		return (*((insert(value_type(k, T()))).first)).second;
	}

	void swap(map<Key, T, Compare, Alloc>& x) { t.swap(x.t); }

	// insert/erase
	//都是调用底层RB-tree的操作行为
	pair<iterator, bool> insert(const value_type& x) { return t.insert_unique(x); }
	iterator insert(iterator position, const value_type& x) {
		return t.insert_unique(position, x);
	}

	void erase(iterator position) { t.erase(position); }
	size_type erase(const key_type& x) { return t.erase(x); }
	void erase(iterator first, iterator last) { t.erase(first, last); }
	void clear() { t.clear(); }

	// map operations:
	/*返回一个迭代器指向键值为key的元素，如果没找到就返回end()*/
	iterator find(const key_type& x) { return t.find(x); }
	const_iterator find(const key_type& x) const { return t.find(x); }
	/*返回键值等于key的元素的个数*/
	size_type count(const key_type& x) const { return t.count(x); }
	/*返回一个迭代器，指向键值>=key的第一个元素*/
	iterator lower_bound(const key_type& x) { return t.lower_bound(x); }
	const_iterator lower_bound(const key_type& x) const {
		return t.lower_bound(x);
	}
	/*返回一个迭代器，指向键值>key的第一个元素*/
	iterator upper_bound(const key_type& x) { return t.upper_bound(x); }
	const_iterator upper_bound(const key_type& x) const {
		return t.upper_bound(x);
	}
	/*返回键值为key的元素的第一个可安插位置和最后一个可安插位置，也就是“键值==key”的元素区间*/
	pair<iterator, iterator> equal_range(const key_type& x) {
		return t.equal_range(x);
	}
	pair<const_iterator, const_iterator> equal_range(const key_type& x) const {
		return t.equal_range(x);
	}
	friend bool operator==(const map&, const map&);
	friend bool operator<(const map&, const map&);
};

/*运算符重载，几乎有所有的操作行为都是调用RB-tree的操作行为
事实上，包括set在内的关联式容器内部都是以RB-tree方式存放的*/
template <class Key, class T, class Compare, class Alloc>
inline bool operator==(const map<Key, T, Compare, Alloc>& x,
	const map<Key, T, Compare, Alloc>& y) {
	return x.t == y.t;
}

template <class Key, class T, class Compare, class Alloc>
inline bool operator<(const map<Key, T, Compare, Alloc>& x,
	const map<Key, T, Compare, Alloc>& y) {
	return x.t < y.t;
}

通常，关联式容器并不提供元素的直接存取，你必须依靠迭代器，不过 map 内部的下标操作符重载函数使得其支持元素的直接存取，看看它是怎么实现的

这是map作为关联式容器特殊的地方（multimap没有哦）

	/*下面这个下标操作符重载函数是的map支持元素的直接存取，索引值是元素的key*/
	T& operator[](const key_type& k) 
	{
		return (*((insert(value_type(k, T()))).first)).second;
	}
	/*map中的元素，是一个由键值和实值组成的pair
	value_type(k, T()) //typedef pair<const Key, T> value_type;产生一个与实值型别相同的暂时对象替代
	                   //就是产生一个键值为k，实值未知的对象
	insert(value_type(k, T())) //将该元素插入到map里面，该操作返回一个pair，其第一个元素是个迭代器
	                           //指向插入妥当的新元素或指向插入失败点(键值重复)的旧元素
	*((insert(value_type(k, T()))).first) //先取插入操作所返回的pair的第一元素，即指向被插入元素的迭代器
	                                      //然后通过指针运算符提领该迭代器
	(*((insert(value_type(k, T()))).first)).second //取其第二个元素，也就是实值
	*/

操作 m[key] 返回一个 reference，指向键值为key 的元素的实值，如果该元素尚未存在，就安插该元素。map 是根据键值 key来排序的，实值不影响。

因为是返回一个 reference，可作为左值，并且是指向可修改的实值，所以同样可以利用下标操作符修改对应键值的实值。set 不具备的原因就是，其键值就是实值，不可修改。

二、multimap

同multiset类似，multimap 的特性以及用法几乎与map 完全相同，唯一的差别在于它允许键值重复，当然还有上面说到的这个直接存取，插入操作采用的是底层机制RB-tree 的 insert_equal()。

#include <iostream>
#include <map>

using namespace std;

int main()
{
	map<string, int> imap; //以string 为键值，以int 为实值
	/*利用下标操作符，不存在的元素则安插（源码得知，内部调用insert()函数）*/
	imap[string("qwer")] = 1; 
	imap[string("tyui")] = 2;
	imap[string("asdf")] = 3;
	imap[string("ghjk")] = 4;

	pair<string, int> value(string("zxcv"), 5);
	imap.insert(value);

	int number = imap[string("zxcv")];//下标操作符获取元素的实值
	cout << number << endl; // 5

	imap[string("zxcv")] = 1;//左值运用
	number = imap[string("zxcv")];
	cout << number << endl; // 1

	return 0;
}

关联式容器如set和map(multi..) 的erase操作，并没有返回值，不像序列式容器返回删除元素的下一个迭代器，所以一旦执行erase操作，如果不做处理极易发生危险。比如下面操作：

for (pos = stocks.begin(); pos != stocks.end(); ++pos)
{
	if (pos->second == value)
		stocks.erase(pos);//删除了pos。pos立马失效，++pos立即出错
}

map应用案例

#include <iostream> 
#include <map>
#include <string>

using namespace std;

int main()
{
	typedef map<string, double> StringDoubleMap;

	StringDoubleMap stocks;

	/*不知道是哪一年的股票价格*/
	stocks["BASF"] = 369.50;
	stocks["VM"] = 413.50;
	stocks["Daimler"] = 819.10;
	stocks["BMW"] = 834.30;
	stocks["Siemens"] = 842.20;

	StringDoubleMap::iterator pos;
	for (pos = stocks.begin(); pos != stocks.end(); ++pos)
	{
		cout << "stocks: " << pos->first << "\t"
			<< "price: " << pos->second << endl;
	}
	cout << endl;
	/*移除迭代器所指元素*/
	double Express = 0.000001;
	for (pos = stocks.begin(); pos != stocks.end();)
	{
		if (abs(pos->second - 834.30) < Express)
			stocks.erase(pos++);//这里是防止迭代器失效
		else
			++pos;
	}
	for (pos = stocks.begin(); pos != stocks.end(); ++pos)
	{
		cout << "stocks: " << pos->first << "\t"
			<< "price: " << pos->second << endl;
	}
	cout << endl;

	return 0;
}

参考书籍《STL 源码剖析》、《STL 标准程序库》