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>> >
	  unordered_map( InputIt, InputIt,
			 typename /*see	 below*/::size_type  =	/*see	   (1)
       (since C++17)
	  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>> >
	  unordered_map(   std::initializer_list<std::pair<Key,	 T>>,	   (2)
       (since 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 )
	      ->   unordered_map<iter_key_t<InputIt>,			   (3)
       (since C++17)
	  iter_val_t<InputIt>,
			       std::hash<iter_key_t<InputIt>>,

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

	  unordered_map( InputIt, InputIt, Alloc )
	      -> unordered_map<iter_key_t<InputIt>,
	  iter_val_t<InputIt>,						   (4)
       (since 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, Alloc )
	      ->   unordered_map<iter_key_t<InputIt>,			   (5)
       (since C++17)
	  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>>,
			 typename  /*see  below*/::size_type,  Alloc  )	   (6)
       (since C++17)

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

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

	      -> unordered_map<Key, T, Hash, std::equal_to<Key>,
	  Alloc>;
	  template< ranges::input_range	R,

		    class Hash = std::hash<range_key_t<R>>,
		    class Pred = std::equal_to<range_key_t<R>>,
		    class Alloc	= std::allocator<range_to_alloc_t<R>>
	  >
	  unordered_map(  std::from_range_t,  R&&,			   (9)
       (since C++23)
			 typename /* see description */::size_type =
	  /* see description */,
			 Hash =	Hash(),	Pred = Pred(), Alloc = Alloc()
	  )
	      -> unordered_map<range_key_t<R>, range_mapped_t<R>,

			       Hash, Pred, Alloc>;
	  template< ranges::input_range	R, class Alloc >

	  unordered_map( std::from_range_t, R&&,
			 typename /* see description */::size_type,
	  Alloc	  )							  (10)
       (since C++23)
	      -> unordered_map<range_key_t<R>, range_mapped_t<R>,
			       std::hash<range_key_t<R>>,

			       std::equal_to<range_key_t<R>>, Alloc>;
	  template< ranges::input_range	R, class Alloc >

	  unordered_map( std::from_range_t, R&&, Alloc )
	      ->  unordered_map<range_key_t<R>,	 range_mapped_t<R>,	  (11)
       (since C++23)
			       std::hash<range_key_t<R>>,

			       std::equal_to<range_key_t<R>>, Alloc>;
	  template< ranges::input_range	R, class Hash, class Alloc >

	  unordered_map( std::from_range_t, R&&, typename /* see
	  description */::size_type,
			 Hash,	Alloc  )				  (12)
       (since C++23)
	      -> unordered_map<range_key_t<R>, range_mapped_t<R>,
	  Hash,

			       std::equal_to<range_key_t<R>>, Alloc>;
	  Exposition-only helper type aliases
	  template< class InputIter >

	  using				 iter_val_t			     =
       (exposition only*)

	      typename std::iterator_traits<InputIter>::value_type;
	  template< class InputIter >

	  using				 iter_key_t			     =
       (exposition only*)

	      std::remove_const_t< std::tuple_element_t<0,
	  iter_val_t<InputIter>>>;
	  template< class InputIter >

	  using			       iter_mapped_t			     =
       (exposition only*)

	      std::tuple_element_t<1, iter_val_t<InputIter>>;
	  template< class InputIter >

	  using	iter_to_alloc_t	=
	      std::pair<std::add_const_t<tuple_element_t<0,
       (exposition only*)
	  iter_val_t<InputIter>>>,

			std::tuple_element_t<1,
	  iter_val_t<InputIter>>>;
	  template< ranges::input_range	Range >

	  using				 range_key_t			     =
       (since C++23)
									    (ex-
       position	only*)
	      std::remove_const_t<typename
	  ranges::range_value_t<Range>::first_type>;
	  template< ranges::input_range	Range >
									    (since
       C++23)
	  using			       range_mapped_t			     =
       (exposition only*)

	      typename ranges::range_value_t<Range>::second_type;
	  template< ranges::input_range	Range >

	  using	range_to_alloc_t =
	      std::pair<std::add_const_t<typename
       (since C++23)
	  ranges::range_value_t<Range>::first_type>,
       (exposition only*)

			typename
	  ranges::range_value_t<Range>::second_type>;

	  1-8)	These  deduction guide are provided for	unordered_map to allow
       deduction from an
	  iterator range (overloads (1,3-5)) and std::initializer_list	(over-
       loads (2,6-8)).
	  9-12)	These deduction	guides are provided for	unordered_map to allow
       deduction from
	  a std::from_range_t tag and an input_range.

	  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.

Notes
	      Feature-test macro       Value	Std		      Feature
	  __cpp_lib_containers_ranges  202202L	(C++23)	Ranges-aware construc-
       tion and	insertion;
						      overloads	(9-12)

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		  2024.06.10	  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.1.quarterly>

home | help