unordered_map

C语言库函数的原型,有用的拿去

	class _Ty,
	class _Hasher,
	class _Keyeq,
	class _Alloc>
	void swap(unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Left,
		unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Right)
	{	// swap _Left and _Right unordered_maps
	_Left.swap(_Right);
	}

template<class _Kty,
	class _Ty,
	class _Tr,
	class _Alloc> inline
	void swap(unordered_map<_Kty, _Ty, _Tr, _Alloc>& _Left,
		unordered_map<_Kty, _Ty, _Tr, _Alloc>&& _Right)
	{	// swap _Left and _Right unordered_maps
	typedef unordered_map<_Kty, _Ty, _Tr, _Alloc> _Myt;
	_Left.swap(_STD forward<_Myt>(_Right));
	}

template<class _Kty,
	class _Ty,
	class _Tr,
	class _Alloc> inline
	void swap(unordered_map<_Kty, _Ty, _Tr, _Alloc>&& _Left,
		unordered_map<_Kty, _Ty, _Tr, _Alloc>& _Right)
	{	// swap _Left and _Right unordered_maps
	typedef unordered_map<_Kty, _Ty, _Tr, _Alloc> _Myt;
	_Right.swap(_STD forward<_Myt>(_Left));
	}

		// TEMPLATE CLASS unordered_multimap
template<class _Kty,
	class _Ty,
	class _Hasher = _STD tr1::hash<_Kty>,
	class _Keyeq = _STD equal_to<_Kty>,
	class _Alloc = _STD allocator<_STD pair<const _Kty, _Ty> > >
	class unordered_multimap
		: public _Hash<_STD tr1::_Umap_traits<_Kty, _Ty,
			_Hash_compare<_Kty, _Hasher, _Keyeq>, _Alloc, true> >
	{	// hash table of {key, mapped} values, non-unique keys
public:
	typedef unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc> _Myt;
	typedef _Hash_compare<_Kty, _Hasher, _Keyeq> _Mytraits;
	typedef _Hash<_STD tr1::_Umap_traits<_Kty, _Ty,
		_Mytraits, _Alloc, true> > _Mybase;
	typedef _Hasher hasher;
	typedef _Kty key_type;
	typedef _Ty mapped_type;
	typedef _Ty referent_type;	// extra
	typedef _Keyeq key_equal;
	typedef _Mytraits key_compare;	// extra

//	typedef typename _Mybase::value_compare value_compare;
	typedef typename _Mybase::allocator_type allocator_type;
	typedef typename _Mybase::size_type size_type;
	typedef typename _Mybase::difference_type difference_type;
	typedef typename _Mybase::pointer pointer;
	typedef typename _Mybase::const_pointer const_pointer;
	typedef typename _Mybase::reference reference;
	typedef typename _Mybase::const_reference const_reference;
	typedef typename _Mybase::iterator iterator;
	typedef typename _Mybase::const_iterator const_iterator;
//	typedef typename _Mybase::reverse_iterator reverse_iterator;
//	typedef typename _Mybase::const_reverse_iterator
//		const_reverse_iterator;
	typedef typename _Mybase::value_type value_type;

	typedef typename _Mybase::iterator local_iterator;
	typedef typename _Mybase::const_iterator const_local_iterator;

	unordered_multimap()
		: _Mybase(key_compare(), allocator_type())
		{	// construct empty map from defaults
		}

	unordered_multimap(const _Myt& _Right)
		: _Mybase(_Right)
		{	// construct map by copying _Right
		}

	explicit unordered_multimap(size_type _Buckets)
		: _Mybase(key_compare(), allocator_type())
		{	// construct empty map from defaults, ignore initial size
		this->rehash(_Buckets);
		}

	unordered_multimap(size_type _Buckets, const hasher& _Hasharg)
		: _Mybase(key_compare(_Hasharg), allocator_type())
		{	// construct empty map from hasher
		this->rehash(_Buckets);
		}

	unordered_multimap(size_type _Buckets, const hasher& _Hasharg,
		const _Keyeq& _Keyeqarg)
		: _Mybase(key_compare(_Hasharg, _Keyeqarg), allocator_type())
		{	// construct empty map from hasher and equality comparator
		this->rehash(_Buckets);
		}

	unordered_multimap(size_type _Buckets, const hasher& _Hasharg,
		const _Keyeq& _Keyeqarg, const allocator_type& _Al)
		: _Mybase(key_compare(_Hasharg, _Keyeqarg), _Al)
		{	// construct empty map from hasher and equality comparator
		this->rehash(_Buckets);
		}

	template<class _Iter>
		unordered_multimap(_Iter _First, _Iter _Last)
		: _Mybase(key_compare(), allocator_type())
		{	// construct map from sequence, defaults
		for (; _First != _Last; ++_First)
			_Mybase::insert(*_First);
		}

	template<class _Iter>
		unordered_multimap(_Iter _First, _Iter _Last,
			size_type _Buckets)
		: _Mybase(key_compare(), allocator_type())
		{	// construct map from sequence, defaults, ignore initial size
		this->rehash(_Buckets);
		for (; _First != _Last; ++_First)
			_Mybase::insert(*_First);
		}

	template<class _Iter>
		unordered_multimap(_Iter _First, _Iter _Last,
			size_type _Buckets, const hasher& _Hasharg)
		: _Mybase(key_compare(_Hasharg), allocator_type())
		{	// construct map from sequence, comparator
		this->rehash(_Buckets);
		for (; _First != _Last; ++_First)
			_Mybase::insert(*_First);
		}

	template<class _Iter>
		unordered_multimap(_Iter _First, _Iter _Last,
			size_type _Buckets, const hasher& _Hasharg,
			const _Keyeq& _Keyeqarg)
		: _Mybase(key_compare(_Hasharg, _Keyeqarg), allocator_type())
		{	// construct map from sequence, comparator, and allocator
		this->rehash(_Buckets);
		for (; _First != _Last; ++_First)
			_Mybase::insert(*_First);
		}

	template<class _Iter>
		unordered_multimap(_Iter _First, _Iter _Last,
			size_type _Buckets, const hasher& _Hasharg,
			const _Keyeq& _Keyeqarg, const allocator_type _Al)
		: _Mybase(key_compare(_Hasharg, _Keyeqarg), _Al)
		{	// construct map from sequence, comparator, and allocator
		this->rehash(_Buckets);
		for (; _First != _Last; ++_First)
			_Mybase::insert(*_First);
		}

	_Myt& operator=(const _Myt& _Right)
		{	// assign by copying _Right
		_Mybase::operator=(_Right);
		return (*this);
		}

	unordered_multimap(_Myt&& _Right)
		: _Mybase(_STD move(_Right))
		{	// construct map by moving _Right
		}

	_Myt& operator=(_Myt&& _Right)
		{	// assign by moving _Right
		_Mybase::operator=(_STD move(_Right));
		return (*this);
		}

	template<class _Valty>
		iterator insert(_Valty&& _Val)
		{	// insert a {key, mapped} value
		return (_Mybase::insert(_STD forward<_Valty>(_Val)).first);
		}

	template<class _Valty>
		typename _STD tr1::enable_if<!_STD tr1::is_same<const_iterator,
			typename _STD tr1::remove_reference<_Valty>::type>::value,
				iterator>::type
		insert(const_iterator _Where, _Valty&& _Val)
		{	// insert a {key, mapped} value, with hint
		return (_Mybase::insert(_Where, _STD forward<_Valty>(_Val)));
		}

	void swap(_Myt& _Right)
		{	// exchange contents with non-movable _Right
		_Mybase::swap(_Right);
		}

	void swap(_Myt&& _Right)
		{	// exchange contents with movable _Right
		_Mybase::swap(_STD move(_Right));
		}

	hasher hash_function() const
		{	// return hasher object
		return (this->comp._Hashobj);
		}

	key_equal key_eq() const
		{	// return equality comparator object
		return (this->comp._Keyeqobj);
		}

 #if _HAS_CPP0X

 #else /* _HAS_CPP0X */

 #if _HAS_STRICT_CONFORMANCE
	void erase(const_iterator _Where)
		{	// erase element at _Where
		_Mybase::erase(_Where);
		}

	size_type erase(const key_type& _Keyval)
		{	// erase and count all that match _Keyval
		return (_Mybase::erase(_Keyval));
		}

	void erase(const_iterator _First, const_iterator _Last)
		{	// erase [_First, _Last)
		_Mybase::erase(_First, _Last);
		}
 #endif /* _HAS_STRICT_CONFORMANCE */

 #endif /* _HAS_CPP0X */

	iterator insert(const value_type& _Val)
		{	// insert a {key, mapped} value
		return (_Mybase::insert(_Val).first);
		}

	iterator insert(const_iterator _Where, const value_type& _Val)
		{	// insert a {key, mapped} value, with hint
		return (_Mybase::insert(_Where, _Val));
		}

	template<class _Iter>
		void insert(_Iter _First, _Iter _Last)
		{	// insert [_First, _Last), arbitrary iterators
		_DEBUG_RANGE(_First, _Last);
		_Mybase::insert(_First, _Last);
		}
	};

template<class _Kty,
	class _Ty,
	class _Hasher,
	class _Keyeq,
	class _Alloc>
	void swap(unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Left,
		unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Right)
	{	// swap _Left and _Right unordered_multimaps
	_Left.swap(_Right);
	}

template<class _Kty,
	class _Ty,
	class _Tr,
	class _Alloc> inline
	void swap(unordered_multimap<_Kty, _Ty, _Tr, _Alloc>& _Left,
		unordered_multimap<_Kty, _Ty, _Tr, _Alloc>&& _Right)
	{	// swap _Left and _Right unordered_multimaps
	typedef unordered_multimap<_Kty, _Ty, _Tr, _Alloc> _Myt;
	_Left.swap(_STD forward<_Myt>(_Right));
	}

template<class _Kty,
	class _Ty,
	class _Tr,
	class _Alloc> inline
	void swap(unordered_multimap<_Kty, _Ty, _Tr, _Alloc>&& _Left,
		unordered_multimap<_Kty, _Ty, _Tr, _Alloc>& _Right)
	{	// swap _Left and _Right unordered_multimaps
	typedef unordered_multimap<_Kty, _Ty, _Tr, _Alloc> _Myt;
	_Right.swap(_STD forward<_Myt>(_Left));
	}
	}	// namespace tr1

 #if _HAS_TR1_IMPORTS
using tr1::unordered_map;
using tr1::unordered_multimap;
 #endif /* _HAS_TR1_IMPORTS */
_STD_END
 #pragma warning(pop)
 #pragma pack(pop)

#endif /* RC_INVOKED */
#endif /* _UNORDERED_MAP_ */

/*
 * Copyright (c) 1992-2009 by P.J. Plauger.  ALL RIGHTS RESERVED.
 * Consult your license regarding permissions and restrictions.
V5.20:0009 */