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

FreeBSD Manual Pages

  
 
  

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

NAME
       deductionguidesforstd::unordered_multiset  - deductionguidesforstd::un-
       ordered_multiset

Synopsis
	  Defined in header <unordered_set>
	  template<

	      class InputIt,
	      class Hash = std::hash<typename
	  std::iterator_traits<InputIt>::value_type>,
	      class Pred = std::equal_to<typename
	  std::iterator_traits<InputIt>::value_type>,
	      class Alloc = std::allocator<typename
	  std::iterator_traits<InputIt>::value_type>			     >
       (1)  (since C++17)
	  unordered_multiset( InputIt, InputIt,
			      typename /* see below */::size_type = /* see
	  below	*/,
			      Hash = Hash(), Pred = Pred(), Alloc = Alloc()
	  )
	      -> unordered_multiset<typename
	  std::iterator_traits<InputIt>::value_type,

				    Hash, Pred,	Alloc>;
	  template< class T,

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

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

	  unordered_multiset( InputIt, InputIt,	typename /* see	below
	  */::size_type, Alloc )
	      -> unordered_multiset<typename
	  std::iterator_traits<InputIt>::value_type,
       (3)  (since C++17)
				    std::hash<typename
	  std::iterator_traits<InputIt>::value_type>,
				    std::equal_to<typename
	  std::iterator_traits<InputIt>::value_type>,

				    Alloc>;
	  template< class InputIt, class Hash, class Alloc >

	  unordered_multiset( InputIt, InputIt,	typename /* see	below
	  */::size_type, Hash, Alloc )
	      ->				   unordered_multiset<typename
       (4)  (since C++17)
	  std::iterator_traits<InputIt>::value_type, Hash,
				    std::equal_to<typename
	  std::iterator_traits<InputIt>::value_type>,

				    Alloc>;
	  template< class T, class Alloc >

	  unordered_multiset( std::initializer_list<T>,	typename /* see
	  below		      */::size_type,		  Alloc		     )
       (5)  (since C++17)

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

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

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

		    class Hash = std::hash<ranges::range_value_t<R>>,
		    class Pred = std::equal_to<ranges::range_value_t<R>>,
		    class Alloc	= std::allocator<ranges::range_value_t<R>>
	  >
	  unordered_multiset(		   std::from_range_t,		  R&&,
       (7)  (since C++23)
			      typename /* see below */::size_type = /* see
	  below	*/,
			      Hash = Hash(), Pred = Pred(), Alloc = Alloc()
	  )

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

	  unordered_multiset( std::from_range_t, R&&,
			      typename /* see below */::size_type, Alloc )
	      ->		  unordered_multiset<ranges::range_value_t<R>,
       (8)  (since C++23)
	  hash<ranges::range_value_t<R>>,

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

	  unordered_multiset( std::from_range_t, R&&, Alloc )
	      ->		  unordered_multiset<ranges::range_value_t<R>,
       (9)  (since C++23)
	  hash<ranges::range_value_t<R>>,

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

	  unordered_multiset( std::from_range_t, R&&,
			      typename /* see below */::size_type, Hash,
	  Alloc								     )
       (10) (since C++23)
	      -> unordered_multiset<ranges::range_value_t<R>, Hash,

	  std::equal_to<ranges::range_value_t<R>>, Alloc>;

	  1-6)	These  deduction guides	are provided for unordered_multiset to
       allow deduction
	  from an iterator range (overloads (1,3,4)) and std::initializer_list
       (overloads
	  (2,5,6)). This overload participates in overload resolution only  if
       InputIt
	  satisfies  LegacyInputIterator,  Alloc  satisfies Allocator, neither
       Hash nor	Pred
	  satisfy Allocator, Hash is not an integral type.
	  7-10)	These deduction	guides are provided for	unordered_multiset  to
       allow deduction
	  from a std::from_range_t tag and an input_range.

	  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 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	(7-10)

Example
       // Run this code

	#include <unordered_set>

	int main()
	{
	    // guide #2	deduces	std::unordered_multiset<int>
	    std::unordered_multiset s =	{1, 2, 3, 4};

	    // guide #1	deduces	std::unordered_multiset<int>
	    std::unordered_multiset s2(s.begin(), s.end());
	}

http://cppreference.com		  2024.06.10	 deductiongu...red_multiset(3)

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

home | help