deductiongu...td::flat_set(3)

💅 deductiongu...td::flat_set(3) 💅

okay so bestie, you're on the deductiongu...td::flat_set(3) page from the C++ Standard Libary manual. it's giving C++23 deduction-guide realness, and we're gonna go through every single one. no skipping, fr fr. 🫶✨

🌸 NAME 🌸

deductionguidesforstd::flat_set — deductionguidesforstd::flat_set

🦋 Synopsis 🦋

all of these are (since C++23), and the whole thing is living in header <flat_set>. 💖

          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>;

so these deduction guides exist so deduction can happen from: ✨

1. a container + a comparator.
2. a container + an allocator.
3. a container + a comparator + an allocator.
4. the std::sorted_unique_t tag + a container + a comparator.
5. the std::sorted_unique_t tag + a container + an allocator.
6. the std::sorted_unique_t tag + a container + a comparator + an allocator.
7. an iterator range + a comparator.
8. the std::sorted_unique_t tag + an iterator range + a comparator.
9. the std::from_range_t tag + an input_range range + a comparator + an allocator.
10. the std::from_range_t tag + an input_range range + an allocator.
11. the std::initializer_list + a comparator.
12. the std::sorted_unique_t tag + the std::initializer_list + a comparator.

vibe check: 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 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. not me checking for an example and finding none bestie 🙈

👑 Category 👑

• Todo no example

source: http://cppreference.com · version/date: 2024.06.10 · page: deductiongu...td::flat_set(3) — mwah 💋