home | help 
deductiongu...td::flat_set(3)  C++ Standard Libary deductiongu...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 allo-
     cator.
	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 allocator.
	11) The std::initializer_list and a comparator.
	12)  The  std::sorted_unique_t tag, the std::initializer_list and a com-
     parator.

	These overloads participate in overload resolution only if InputIt  sat-
     isfies
	LegacyInputIterator,  Alloc  satisfies Allocator, and Comp does not sat-
     isfy Allocator.

	Note: the extent to which the library determines that a  type  does  not
     satisfy
	LegacyInputIterator  is  unspecified,  except that as a minimum integral
     types do not
	qualify as input iterators. Likewise, the extent to which it  determines
     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)
home | help