Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help 
deductiongu...red_multimap(3) C++ Standard Libarydeductiongu...red_multimap(3)

NAME
       deductionguidesforstd::unordered_multimap  - deductionguidesforstd::un-
       ordered_multimap

Synopsis
	  Defined in header <unordered_map>
	  template<class InputIt,

	  class	Hash = std::hash<iter_key_t<InputIt>>,
	  class	Pred = std::equal_to<iter_key_t<InputIt>>,
	  class	    Alloc     =	     std::allocator<iter_to_alloc_t<InputIt>>>
       (since
	  unordered_multimap(InputIt,				      InputIt,
       (1) C++17)
	  typename /*see below*/::size_type = /*see below*/,
	  Hash = Hash(), Pred =	Pred(),	Alloc =	Alloc())

	  ->   unordered_multimap<iter_key_t<InputIt>,	  iter_val_t<InputIt>,
       Hash,
	  Pred,	Alloc>;
	  template<class Key, class T, class Hash = std::hash<Key>,

	  class	Pred = std::equal_to<Key>,
	  class	   Alloc    =	 std::allocator<std::pair<const	   Key,	  T>>>
       (since
	  unordered_multimap(std::initializer_list<std::pair<Key,	  T>>,
       (2) C++17)
	  typename /*see below*/::size_type = /*see below*/,
	  Hash = Hash(), Pred =	Pred(),	Alloc =	Alloc())

	  -> unordered_multimap<Key, T,	Hash, Pred, Alloc>;
	  template<class InputIt, class	Alloc>

	  unordered_multimap(InputIt,	  InputIt,    typename	  /*see	   be-
       low*/::size_type,
	  Alloc)
       (3) (since
	  ->   unordered_multimap<iter_key_t<InputIt>,	  iter_val_t<InputIt>,
       C++17)
	  std::hash<iter_key_t<InputIt>>,

	  std::equal_to<iter_key_t<InputIt>>, Alloc>;
	  template<class InputIt, class	Alloc>

	  unordered_multimap(InputIt,		   InputIt,		Alloc)
       (since
	  ->   unordered_multimap<iter_key_t<InputIt>,	  iter_val_t<InputIt>,
       (4) C++17)
	  std::hash<iter_key_t<InputIt>>,

	  std::equal_to<iter_key_t<InputIt>>, Alloc>;
	  template<class InputIt, class	Hash, class Alloc>

	  unordered_multimap(InputIt,	  InputIt,    typename	  /*see	   be-
       low*/::size_type,      (since
	  Hash,								Alloc)
       (5) C++17)
	  ->	unordered_multimap<iter_key_t<InputIt>,	  iter_val_t<InputIt>,
       Hash,

	  std::equal_to<iter_key_t<InputIt>>, Alloc>;
	  template<class Key, class T, typename	Alloc>

	  unordered_multimap(std::initializer_list<std::pair<Key,	  T>>,
       (since
	  typename	    /*see	   below*/::size_type,		Alloc)
       (6) C++17)

	  -> unordered_multimap<Key, T,	std::hash<Key>,	std::equal_to<Key>,
	  Alloc>;
	  template<class Key, class T, typename	Alloc>

	  unordered_multimap(std::initializer_list<std::pair<Key, T>>,	Alloc)
       (7) (since
										       C++17)
	  -> unordered_multimap<Key, T,	std::hash<Key>,	std::equal_to<Key>,
	  Alloc>;
	  template<class Key, class T, class Hash, class Alloc>

	  unordered_multimap(std::initializer_list<std::pair<Key,	  T>>,
       (8) (since
	  typename	/*see	   below*/::size_type,	    Hash,	Alloc)
       C++17)

	  -> unordered_multimap<Key, T,	Hash, std::equal_to<Key>, Alloc>;

	  where	 the  type aliases iter_key_t, iter_val_t, iter_to_alloc_t are
       defined as if as
	  follows

	  template< class InputIt >
										   (ex-
       position
	  using		 iter_key_t	      =		  std::remove_const_t<
       only)

	  typename std::iterator_traits<InputIt>::value_type::first_type>;
	  template<		   class	       InputIt		     >
       (exposition
	  using		     iter_val_t		      =		      typename
       only)
	  std::iterator_traits<InputIt>::value_type::second_type;
	  template< class InputIt >

	  using	iter_to_alloc_t	= std::pair<
	  std::add_const_t<typename
       (exposition
	  std::iterator_traits<InputIt>::value_type::first_type>,
       only)
	  typename std::iterator_traits<InputIt>::value_type::second_type

	  >

	  These	 deduction  guide are provided for unordered_multimap to allow
       deduction from an
	  iterator range (overloads (1,3-5)) and std::initializer_list	(over-
       loads (2,6-8)).
	  These	 overloads  participate	in overload resolution only if InputIt
       satisfies
	  LegacyInputIterator, Alloc satisfies	Allocator,  neither  Hash  nor
       Pred satisfy
	  Allocator, and Hash is not an	integral type.

	  Note:	 the  extent  to which the library determines that a type does
       not satisfy
	  LegacyInputIterator is unspecified, except that as a	minimum	 inte-
       gral types do not
	  qualify  as input iterators. Likewise, the extent to which it	deter-
       mines that a type
	  does not satisfy Allocator is	unspecified, except that as a  minimum
       the member type
	  Alloc::value_type must exist and the expression
	  std::declval<Alloc&>().allocate(std::size_t{})  must	be well-formed
       when treated as
	  an unevaluated operand.

	  The size_type	parameter type in these	guides in  an  refers  to  the
       size_type member
	  type of the type deduced by the deduction guide.

Example
       // Run this code

	#include <unordered_map>
	int main() {
	//  std::unordered_multimap  m1	 = {{"foo", 1},	{"bar",	2}}; //	Error:
       braced-init-list	has no type
								  //	cannot
       deduce pair<Key,	T> from
								  //   {"foo",
       1} or {"bar", 2}
	   std::unordered_multimap m1 =	{std::pair{"foo", 2}, {"bar", 3}};  //
       guide #2
	   std::unordered_multimap m2(m1.begin(), m1.end()); //	guide #1
	}

	 Defect	reports

	  The following	behavior-changing defect reports were applied retroac-
       tively to
	  previously published C++ standards.

	     DR	       Applied	   to		   Behavior    as    published
       Correct behavior
	  LWG 3025 C++17      initializer-list guides  take		   use
       std::pair<Key, T>
			      std::pair<const Key, T>

http://cppreference.com		  2022.07.31	 deductiongu...red_multimap(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=deductionguidesforstd::unordered_multimap&sektion=3&manpath=FreeBSD+Ports+15.0>

home | help