map

最新推荐文章于 2022-06-29 11:26:50 发布

夜深矣

最新推荐文章于 2022-06-29 11:26:50 发布

阅读量170

点赞数

分类专栏： STL 文章标签： stl map

本文链接：https://blog.csdn.net/qq_40822303/article/details/102654115

版权

STL 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

概念

map/multimap和set一样是以rb_tree（红黑树）为底层结构，因此有'元素自动排序‘的特性（根由是因为红黑树会自动排序），排序的依据是key;同样的，map/multimap提供“遍历”操作及迭代器（iterator），按正常规则（++iter）遍历，便能获得排序后的状态。

和set/multiset的区别：

set/multiset的每一个元素即是key，也是value（即二者是同一个值）。

map/multimap的每一个元素是value，value里面包含key和data。

注意：

map/multimap的key有其严谨的排列规则，因此在map/multimap内部自动将user指定的key的类型设为const以禁止user对元素的key赋值。所以仅可通过map/multimap的iterator改变元素的data，无法改变元素的key。

map的源码(sgi_stl):

template <class _Key, class _Tp, class _Compare, class _Alloc>
class map {
public:
	// typedefs:

	typedef _Key                  key_type;
	typedef _Tp                   data_type;
	typedef _Tp                   mapped_type;
	typedef pair<const _Key, _Tp> value_type;
	typedef _Compare              key_compare;

	class value_compare
		: public binary_function<value_type, value_type, bool> {
		friend class map<_Key, _Tp, _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 _M_t;  // red-black tree representing map
public:
	typedef typename _Rep_type::pointer pointer;
	typedef typename _Rep_type::const_pointer const_pointer;
	typedef typename _Rep_type::reference reference;
	typedef typename _Rep_type::const_reference const_reference;
	typedef typename _Rep_type::iterator iterator;
	typedef typename _Rep_type::const_iterator const_iterator;
	typedef typename _Rep_type::reverse_iterator reverse_iterator;
	typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
	typedef typename _Rep_type::size_type size_type;
	typedef typename _Rep_type::difference_type difference_type;
	typedef typename _Rep_type::allocator_type allocator_type;

	// allocation/deallocation

	map() : _M_t(_Compare(), allocator_type()) {}
	explicit map(const _Compare& __comp,
		const allocator_type& __a = allocator_type())
		: _M_t(__comp, __a) {}

#ifdef __STL_MEMBER_TEMPLATES
	template <class _InputIterator>
	map(_InputIterator __first, _InputIterator __last)
		: _M_t(_Compare(), allocator_type())
	{
		_M_t.insert_unique(__first, __last);
	}

	template <class _InputIterator>
	map(_InputIterator __first, _InputIterator __last, const _Compare& __comp,
		const allocator_type& __a = allocator_type())
		: _M_t(__comp, __a) {
		_M_t.insert_unique(__first, __last);
	}
#else
	map(const value_type* __first, const value_type* __last)
		: _M_t(_Compare(), allocator_type())
	{
		_M_t.insert_unique(__first, __last);
	}

	map(const value_type* __first,
		const value_type* __last, const _Compare& __comp,
		const allocator_type& __a = allocator_type())
		: _M_t(__comp, __a) {
		_M_t.insert_unique(__first, __last);
	}

	map(const_iterator __first, const_iterator __last)
		: _M_t(_Compare(), allocator_type())
	{
		_M_t.insert_unique(__first, __last);
	}

	map(const_iterator __first, const_iterator __last, const _Compare& __comp,
		const allocator_type& __a = allocator_type())
		: _M_t(__comp, __a) {
		_M_t.insert_unique(__first, __last);
	}

#endif /* __STL_MEMBER_TEMPLATES */

	map(const map<_Key, _Tp, _Compare, _Alloc>& __x) : _M_t(__x._M_t) {}
	map<_Key, _Tp, _Compare, _Alloc>&
		operator=(const map<_Key, _Tp, _Compare, _Alloc>& __x)
	{
		_M_t = __x._M_t;
		return *this;
	}

	// accessors:

	key_compare key_comp() const { return _M_t.key_comp(); }
	value_compare value_comp() const { return value_compare(_M_t.key_comp()); }
	allocator_type get_allocator() const { return _M_t.get_allocator(); }

	iterator begin() { return _M_t.begin(); }
	const_iterator begin() const { return _M_t.begin(); }
	iterator end() { return _M_t.end(); }
	const_iterator end() const { return _M_t.end(); }
	reverse_iterator rbegin() { return _M_t.rbegin(); }
	const_reverse_iterator rbegin() const { return _M_t.rbegin(); }
	reverse_iterator rend() { return _M_t.rend(); }
	const_reverse_iterator rend() const { return _M_t.rend(); }
	bool empty() const { return _M_t.empty(); }
	size_type size() const { return _M_t.size(); }
	size_type max_size() const { return _M_t.max_size(); }
	_Tp& operator[](const key_type& __k) {
		iterator __i = lower_bound(__k);
		// __i->first is greater than or equivalent to __k.
		if (__i == end() || key_comp()(__k, (*__i).first))
			__i = insert(__i, value_type(__k, _Tp()));
		return (*__i).second;
	}
	void swap(map<_Key, _Tp, _Compare, _Alloc>& __x) { _M_t.swap(__x._M_t); }

	// insert/erase

	pair<iterator, bool> insert(const value_type& __x)
	{
		return _M_t.insert_unique(__x);
	}
	iterator insert(iterator position, const value_type& __x)
	{
		return _M_t.insert_unique(position, __x);
	}
#ifdef __STL_MEMBER_TEMPLATES
	template <class _InputIterator>
	void insert(_InputIterator __first, _InputIterator __last) {
		_M_t.insert_unique(__first, __last);
	}
#else
	void insert(const value_type* __first, const value_type* __last) {
		_M_t.insert_unique(__first, __last);
	}
	void insert(const_iterator __first, const_iterator __last) {
		_M_t.insert_unique(__first, __last);
	}
#endif /* __STL_MEMBER_TEMPLATES */

	void erase(iterator __position) { _M_t.erase(__position); }
	size_type erase(const key_type& __x) { return _M_t.erase(__x); }
	void erase(iterator __first, iterator __last)
	{
		_M_t.erase(__first, __last);
	}
	void clear() { _M_t.clear(); }

	// map operations:

	iterator find(const key_type& __x) { return _M_t.find(__x); }
	const_iterator find(const key_type& __x) const { return _M_t.find(__x); }
	size_type count(const key_type& __x) const {
		return _M_t.find(__x) == _M_t.end() ? 0 : 1;
	}
	iterator lower_bound(const key_type& __x) { return _M_t.lower_bound(__x); }
	const_iterator lower_bound(const key_type& __x) const {
		return _M_t.lower_bound(__x);
	}
	iterator upper_bound(const key_type& __x) { return _M_t.upper_bound(__x); }
	const_iterator upper_bound(const key_type& __x) const {
		return _M_t.upper_bound(__x);
	}

	pair<iterator, iterator> equal_range(const key_type& __x) {
		return _M_t.equal_range(__x);
	}
	pair<const_iterator, const_iterator> equal_range(const key_type& __x) const {
		return _M_t.equal_range(__x);
	}

#ifdef __STL_TEMPLATE_FRIENDS 
	template <class _K1, class _T1, class _C1, class _A1>
	friend bool operator== (const map<_K1, _T1, _C1, _A1>&,
		const map<_K1, _T1, _C1, _A1>&);
	template <class _K1, class _T1, class _C1, class _A1>
	friend bool operator< (const map<_K1, _T1, _C1, _A1>&,
		const map<_K1, _T1, _C1, _A1>&);
#else /* __STL_TEMPLATE_FRIENDS */
	friend bool __STD_QUALIFIER
		operator== __STL_NULL_TMPL_ARGS(const map&, const map&);
	friend bool __STD_QUALIFIER
		operator< __STL_NULL_TMPL_ARGS(const map&, const map&);
#endif /* __STL_TEMPLATE_FRIENDS */