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

FreeBSD Manual Pages

  
 
  

home | help 
deductiongu...ordered_map(3)  C++ Standard Libary deductiongu...ordered_map(3)

NAME
       deductionguidesforstd::unordered_map    -    deductionguidesforstd::un-
       ordered_map

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_map(InputIt,				      InputIt,
       (1) C++17)
	  typename /*see below*/::size_type = /*see below*/,
	  Hash = Hash(), Pred =	Pred(),	Alloc =	Alloc())

	  ->  unordered_map<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_map(std::initializer_list<std::pair<Key,		  T>>,
       (2) C++17)
	  typename /*see below*/::size_type = /*see below*/,
	  Hash = Hash(), Pred =	Pred(),	Alloc =	Alloc())

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

	  unordered_map(InputIt, InputIt, typename /*see below*/::size_type,
	  Alloc)
       (3) (since
	  ->	  unordered_map<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_map(InputIt,		InputIt,		Alloc)
       (since
	  ->	  unordered_map<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_map(InputIt, InputIt, typename  /*see  below*/::size_type,
       Hash,	 (since
	  Alloc)
       (5) C++17)
	  -> unordered_map<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_map(std::initializer_list<std::pair<Key,		  T>>,
       (6) (since
	  typename	    /*see	   below*/::size_type,		Alloc)
       C++17)

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

	  -> unordered_map<Key,	T, std::hash<Key>, std::equal_to<Key>, Alloc>;
	  template<class Key, class T, class Hash, class Alloc>

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

	  -> unordered_map<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_map to allow	deduc-
       tion 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_map 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_map m1 = {std::pair{"foo", 2}, {"bar", 3}}; // guide
       #2
	   std::unordered_map 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...ordered_map(3)

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

home | help