Movatterモバイル変換

[0]ホーム
URL:

cppreference.com
Namespaces
Variants
    Actions

      deduction guides forstd::flat_set

      From cppreference.com
      <cpp‎ |container‎ |flat set

      [edit template]
       
       
       
       
      Defined in header<flat_set>
      template<class KeyContainer,

               class Compare=std::less<typename KeyContainer::value_type>>
      flat_set( KeyContainer, Compare= Compare())

         -> flat_set<typename KeyContainer::value_type, Compare, KeyContainer>;
      		 (1)(since C++23)
      template<class KeyContainer,class Allocator>

      flat_set( KeyContainer, Allocator)
         -> flat_set<typename KeyContainer::value_type,

                     std::less<typename KeyContainer::value_type>, KeyContainer>;
      		 (2)(since C++23)
      template<class KeyContainer,class Compare,class Allocator>

      flat_set( KeyContainer, Compare, Allocator)

         -> flat_set<typename KeyContainer::value_type, Compare, KeyContainer>;
      		 (3)(since C++23)
      template<class KeyContainer,

               class Compare=std::less<typename KeyContainer::value_type>>
      flat_set(std::sorted_unique_t, KeyContainer, Compare= Compare())

         -> flat_set<typename KeyContainer::value_type, Compare, KeyContainer>;
      		 (4)(since C++23)
      template<class KeyContainer,class Allocator>

      flat_set(std::sorted_unique_t, KeyContainer, Allocator)
         -> flat_set<typename KeyContainer::value_type,

                     std::less<typename KeyContainer::value_type>, KeyContainer>;
      		 (5)(since C++23)
      template<class KeyContainer,class Compare,class Allocator>

      flat_set(std::sorted_unique_t, KeyContainer, Compare, Allocator)

         -> flat_set<typename KeyContainer::value_type, Compare, KeyContainer>;
      		 (6)(since C++23)
      template<class InputIt,

               class Compare=std::less</*iter-val-t*/<InputIt>>>
      flat_set( InputIt, InputIt, Compare= Compare())

         -> flat_set</*iter-val-t*/<InputIt>, Compare>;
      		 (7)(since C++23)
      template<class InputIt,

               class Compare=std::less</*iter-val-t*/<InputIt>>>
      flat_set(std::sorted_unique_t, InputIt, InputIt, Compare= Compare())

         -> flat_set</*iter-val-t*/<InputIt>, Compare>;
      		 (8)(since C++23)
      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= Allocator())
         -> flat_set<ranges::range_value_t<R>, Compare,
                     std::vector<ranges::range_value_t<R>,

                     /*alloc-rebind*/<Allocator,ranges::range_value_t<R>>>>;
      		 (9)(since C++23)
      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>>,
                     std::vector<ranges::range_value_t<R>,

                     /*alloc-rebind*/<Allocator,ranges::range_value_t<R>>>>;
      		 (10)(since C++23)
      template<class Key,class Compare=std::less<Key>>

      flat_set(std::initializer_list<Key>, Compare= Compare())

         -> flat_set<Key, Compare>;
      		 (11)(since C++23)
      template<class Key,class Compare=std::less<Key>>

      flat_set(std::sorted_unique_t,
                     std::initializer_list<Key>, Compare= Compare())

         -> flat_set<Key, Compare>;
      		 (12)(since C++23)
      Exposition-only helper type aliases
      template<class InputIt>

      using/*iter-val-t*/=

         typenamestd::iterator_traits<InputIt>::value_type;
      		(exposition only*)
      template<class Allocator,class T>

      using/*alloc-rebind*/=

         typenamestd::allocator_traits<Allocator>::template rebind_alloc<T>;
      		(exposition only*)

      Thesededuction 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) Thestd::sorted_unique_t tag, a container and a comparator.
      5) Thestd::sorted_unique_t tag, a container and an allocator.
      6) Thestd::sorted_unique_t tag, a container, a comparator and an allocator.
      7) An iterator range and a comparator.
      8) Thestd::sorted_unique_t tag, an iterator range and a comparator.
      9) Thestd::from_range_t tag, aninput_range range, a comparator and an allocator.
      10) Thestd::from_range_t tag, aninput_range range and an allocator.
      11) Thestd::initializer_list and a comparator.
      12) Thestd::sorted_unique_t tag, thestd::initializer_list and a comparator.

      These overloads participate in overload resolution only ifInputIt satisfiesLegacyInputIterator,Alloc satisfiesAllocator, andComp does not satisfyAllocator.

      Note: the extent to which the library determines that a type does not satisfyLegacyInputIterator 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 satisfyAllocator is unspecified, except that as a minimum the member typeAlloc::value_type must exist and the expressionstd::declval<Alloc&>().allocate(std::size_t{}) must be well-formed when treated as an unevaluated operand.

      [edit]Example

      This section is incomplete
      Reason: no example
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/container/flat_set/deduction_guides&oldid=171808"
      [8]ページ先頭
      ©2009-2025 Movatter.jp