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

FreeBSD Manual Pages

  
 
  

home | help 
deductiongu...td::flat_set(3) C++ Standard Libarydeductiongu...td::flat_set(3)

NAME
       deductionguidesforstd::flat_set - deductionguidesforstd::flat_set

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

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

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

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

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

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

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

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

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

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

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

	  flat_set( std::sorted_unique_t, KeyContainer,	Compare, Allocator
	  )
       (6)  (since C++23)

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

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

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

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

	      -> flat_set</*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_set( std::from_range_t, R&&,  Compare  =	 Compare(),  Allocator
       (9)  (since C++23)
	  = Allocator()	)
	      -> flat_set<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_set( std::from_range_t, R&&, Allocator )
	      -> flat_set<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_set(   std::initializer_list<Key>,   Compare   =	  Compare()  )
       (11) (since C++23)

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

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

	      -> flat_set<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_unique_t tag, a container and a comparator.
	  5) The std::sorted_unique_t tag, a container and an allocator.
	  6)  The  std::sorted_unique_t	 tag, a	container, a comparator	and an
       allocator.
	  7) An	iterator range and a comparator.
	  8) The std::sorted_unique_t tag, an iterator range and a comparator.
	  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_unique_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...td::flat_set(3)

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

home | help