deductiongu...red_multiset(3)

🌸 NAME 🌸

okay bestie, this is deductiongu...red_multiset(3), fresh outta the C++ Standard Libary (yes, that's the spelling up top, we're not fixing it 💅). The actual NAME is deductionguidesforstd::unordered_multiset — deductionguidesforstd::unordered_multiset. iconic, no spaces, periodt 🦋

✨ Synopsis ✨

Defined in header <unordered_set>. The whole template buffet is below, and yes, it's giving character-for-character realness:

          template<

              class InputIt,
              class Hash = std::hash<typename
          std::iterator_traits<InputIt>::value_type>,
              class Pred = std::equal_to<typename
          std::iterator_traits<InputIt>::value_type>,
              class Alloc = std::allocator<typename
          std::iterator_traits<InputIt>::value_type> >                      (1)
       (since C++17)
          unordered_multiset( InputIt, InputIt,
                              typename /* see below */::size_type = /* see
          below */,
                              Hash = Hash(), Pred = Pred(), Alloc = Alloc()
          )
              -> unordered_multiset<typename
          std::iterator_traits<InputIt>::value_type,

                                    Hash, Pred, Alloc>;
          template< class T,

                    class Hash = std::hash<T>,
                    class Pred = std::equal_to<T>,
                    class Alloc = std::allocator<T> >
          unordered_multiset( std::initializer_list<T>,                     (2)
       (since C++17)
                              typename /* see below */::size_type = /* see
          below */,
                              Hash = Hash(), Pred = Pred(), Alloc = Alloc()
          )

              -> unordered_multiset<T, Hash, Pred, Alloc>;
          template< class InputIt, class Alloc >

          unordered_multiset( InputIt, InputIt, typename /* see below
          */::size_type, Alloc )
              -> unordered_multiset<typename
          std::iterator_traits<InputIt>::value_type,                        (3)
       (since C++17)
                                    std::hash<typename
          std::iterator_traits<InputIt>::value_type>,
                                    std::equal_to<typename
          std::iterator_traits<InputIt>::value_type>,

                                    Alloc>;
          template< class InputIt, class Hash, class Alloc >

          unordered_multiset( InputIt, InputIt, typename /* see below
          */::size_type, Hash, Alloc )
              -> unordered_multiset<typename                                (4)
       (since C++17)
          std::iterator_traits<InputIt>::value_type, Hash,
                                    std::equal_to<typename
          std::iterator_traits<InputIt>::value_type>,

                                    Alloc>;
          template< class T, class Alloc >

          unordered_multiset( std::initializer_list<T>, typename /* see
          below */::size_type, Alloc )                                      (5)
       (since C++17)

              -> unordered_multiset<T, std::hash<T>, std::equal_to<T>,
          Alloc>;
          template< class T, class Hash, class Alloc >

          unordered_multiset( std::initializer_list<T>, typename /* see
          below */::size_type,                                              (6)
       (since C++17)
                              Hash, Alloc )

              -> unordered_multiset<T, Hash, std::equal_to<T>, Alloc>;
          template< ranges::input_range R,

                    class Hash = std::hash<ranges::range_value_t<R>>,
                    class Pred = std::equal_to<ranges::range_value_t<R>>,
                    class Alloc = std::allocator<ranges::range_value_t<R>>
          >
          unordered_multiset( std::from_range_t, R&&,                       (7)
       (since C++23)
                              typename /* see below */::size_type = /* see
          below */,
                              Hash = Hash(), Pred = Pred(), Alloc = Alloc()
          )

              -> unordered_multiset<ranges::range_value_t<R>, Hash, Pred,
          Alloc>;
          template< ranges::input_range R, class Alloc >

          unordered_multiset( std::from_range_t, R&&,
                              typename /* see below */::size_type, Alloc )
              -> unordered_multiset<ranges::range_value_t<R>,               (8)
       (since C++23)
          hash<ranges::range_value_t<R>>,

          std::equal_to<ranges::range_value_t<R>>, Alloc>;
          template< ranges::input_range R, class Alloc >

          unordered_multiset( std::from_range_t, R&&, Alloc )
              -> unordered_multiset<ranges::range_value_t<R>,               (9)
       (since C++23)
          hash<ranges::range_value_t<R>>,

          std::equal_to<ranges::range_value_t<R>>, Alloc>;
          template< ranges::input_range R, class Hash, class Alloc >

          unordered_multiset( std::from_range_t, R&&,
                              typename /* see below */::size_type, Hash,
          Alloc )
       (10) (since C++23)
              -> unordered_multiset<ranges::range_value_t<R>, Hash,

          std::equal_to<ranges::range_value_t<R>>, Alloc>;

1-6) These deduction guides are provided for unordered_multiset to allow deduction from an iterator range (overloads (1,3,4)) and std::initializer_list (overloads (2,5,6)). They participate in overload resolution only if InputIt satisfies LegacyInputIterator, Alloc satisfies Allocator, neither Hash nor Pred satisfies Allocator, and Hash is not an integral type. no cap, that's the eligibility vibe check ✨

7-10) These deduction guides are provided for unordered_multiset to allow deduction from a std::from_range_t tag and an input_range. ranges girlies rise 🌀

Note bestie: 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.

The size_type parameter type in these guides refers to the size_type member type of the type deduced by the deduction guide. iykyk 💜

📝 Notes 📝

Feature-test macro girlies, here's the glow-up info:

• Feature-test macro: __cpp_lib_containers_ranges
• Value: 202202L
• Std: (C++23)
• Feature: Ranges-aware construction and insertion; overloads (7-10)

💻 Example 💻

Run this code, bestie:

        // Run this code

        #include <unordered_set>

        int main()
        {
            // guide #2 deduces std::unordered_multiset<int>
            std::unordered_multiset s = {1, 2, 3, 4};

            // guide #1 deduces std::unordered_multiset<int>
            std::unordered_multiset s2(s.begin(), s.end());
        }

source: http://cppreference.com · version/date: 2024.06.10 · page: deductiongu...red_multiset(3) — hope this helped bestie, mwah 💋✨