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

FreeBSD Manual Pages

  
 
  

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

NAME
       deductionguidesforstd::flat_multiset - deductionguidesforstd::flat_mul-
       tiset

Synopsis
	  Defined in header <flat_set>
	  template< class KeyContainer,

		    class Compare = std::less<typename
	  KeyContainer::value_type>					     >
       (1)  (since C++23)
	  flat_multiset( KeyContainer, Compare = Compare() )

	      -> flat_multiset<typename	KeyContainer::value_type, Compare,
	  KeyContainer>;
	  template< class KeyContainer,	class Allocator	>

	  flat_multiset( KeyContainer, Allocator )
	      ->       flat_multiset<typename	     KeyContainer::value_type,
       (2)  (since C++23)

			       std::less<typename
	  KeyContainer::value_type>, KeyContainer>;
	  template< class KeyContainer,	class Compare, class Allocator >

	  flat_multiset(      KeyContainer,	 Compare,      Allocator     )
       (3)  (since C++23)

	      -> flat_multiset<typename	KeyContainer::value_type, Compare,
	  KeyContainer>;
	  template< class KeyContainer,

		    class Compare = std::less<typename
	  KeyContainer::value_type> >
	  flat_multiset(  std::sorted_equivalent_t,  KeyContainer,  Compare  =
       (4)  (since C++23)
	  Compare() )

	      -> flat_multiset<typename	KeyContainer::value_type, Compare,
	  KeyContainer>;
	  template< class KeyContainer,	class Allocator	>

	  flat_multiset( std::sorted_equivalent_t, KeyContainer, Allocator
	  )
       (5)  (since C++23)
	      -> flat_multiset<typename	KeyContainer::value_type,

			       std::less<typename
	  KeyContainer::value_type>, KeyContainer>;
	  template< class KeyContainer,	class Compare, class Allocator >

	  flat_multiset( std::sorted_equivalent_t, KeyContainer, Compare,
	  Allocator							     )
       (6)  (since C++23)

	      -> flat_multiset<typename	KeyContainer::value_type, Compare,
	  KeyContainer>;
	  template< class InputIter,

		    class Compare =
	  std::less</*iter-value-type*/<InputIter>>			     >
       (7)  (since C++23)
	  flat_multiset( InputIter, InputIter, Compare = Compare() )

	      -> flat_multiset</*iter-value-type*/<InputIter>, Compare>;
	  template< class InputIter,

		    class Compare =
	  std::less</*iter-value-type*/<InputIter>>			     >
       (8)  (since C++23)
	  flat_multiset( std::sorted_equivalent_t, InputIter, InputIter,
	  Compare = Compare() )

	      -> flat_multiset</*iter-value-type*/<InputIter>, Compare>;
	  template< ranges::input_range	R,

		    class Compare = std::less<ranges::range_value_t<R>>,
		    class Allocator =
	  std::allocator<ranges::range_value_t<R>> >
	  flat_multiset(  std::from_range_t,   R&&,   Compare	=   Compare(),
       (9)  (since C++23)
	  Allocator = Allocator() )
	      -> flat_multiset<ranges::range_value_t<R>, Compare,
			       std::vector<ranges::range_value_t<R>,

			       /*alloc-rebind*/<Allocator,
	  ranges::range_value_t<R>>>>;
	  template< ranges::input_range	R, class Allocator >

	  flat_multiset( std::from_range_t, R&&, Allocator )
	      -> flat_multiset<ranges::range_value_t<R>,
	  std::less<ranges::range_value_t<R>>,
       (10) (since C++23)
			       std::vector<ranges::range_value_t<R>,

			       /*alloc-rebind*/<Allocator,
	  ranges::range_value_t<R>>>>;
	  template< class Key, class Compare = std::less<Key> >

	  flat_multiset(  std::initializer_list<Key>,  Compare	=  Compare() )
       (11) (since C++23)

	      -> flat_multiset<Key, Compare>;
	  template< class Key, class Compare = std::less<Key> >

	  flat_multiset(			     std::sorted_equivalent_t,
       (12) (since C++23)
			 std::initializer_list<Key>, Compare = Compare() )

	      -> flat_multiset<Key, Compare>;

	  These	deduction guides are provided for to allow deduction from:

	  1) A container and a comparator.
	  2) A container and an	allocator.
	  3) A container, a comparator and an allocator.
	  4) The std::sorted_equivalent_t tag, a container and a comparator.
	  5) The std::sorted_equivalent_t tag, a container and an allocator.
	  6)  The  std::sorted_equivalent_t tag, a container, a	comparator and
       an allocator.
	  7) An	iterator range and a comparator.
	  8) The std::sorted_equivalent_t tag, an iterator range  and  a  com-
       parator.
	  9) The std::from_range_t tag,	an input_range range, a	comparator and
       an allocator.
	  10)  The  std::from_range_t tag, an input_range range	and an alloca-
       tor.
	  11) The std::initializer_list	and a comparator.
	  12) The std::sorted_equivalent_t tag,	the std::initializer_list  and
       a comparator.

	  These	 overloads  participate	in overload resolution only if InputIt
       satisfies
	  LegacyInputIterator, Alloc satisfies Allocator, and  Comp  does  not
       satisfy Allocator.

	  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.

Example
	   This	section	is incomplete
	   Reason: no example

Category:
	    * Todo no example

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

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

home | help