deductiongu...rstd::deque(3)

💖 deduction guides for std::deque 💖

okay so this page is literally deductiongu...rstd::deque(3) from the C++ Standard Libary, and it’s giving deduction guides energy ✨. bestie, here’s the whole thing, no cap.

✨ NAME ✨

deductionguidesforstd::deque - deductionguidesforstd::deque

🎀 Synopsis 🎀

Defined in header: <deque>

(1) — since C++17

template< class InputIt,
          class Alloc = std::allocator<
              typename std::iterator_traits<InputIt>::value_type>
>
deque( InputIt, InputIt, Alloc = Alloc() )
    -> deque<typename std::iterator_traits<InputIt>::value_type, Alloc>;

(2) — since C++23

template< ranges::input_range R,
          class Alloc = std::allocator<ranges::range_value_t<R>> >
deque( std::from_range_t, R&&, Alloc = Alloc() )
    -> deque<ranges::range_value_t<R>, Alloc>;

1. This deduction guide is lowkey here for deque so you can deduce from an iterator range. This overload participates in overload resolution only if InputIt satisfies LegacyInputIterator and Alloc satisfies Allocator. periodt.
2. This one is also for deque, and it lets you deduce from a std::from_range_t tag plus an input_range. iconic.

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.

💅 Notes 💅

The feature-test macro is having its little main-character moment:

• __cpp_lib_containers_ranges — value 202202L, std (C++23), feature: Ranges-aware construction and insertion; overload (2).

🌸 Example 🌸

// Run this code

#include <deque>
#include <vector>

int main()
{
    std::vector<int> v = {1, 2, 3, 4};

    // uses explicit deduction guide to deduce std::deque<int>
    std::deque x(v.begin(), v.end());

    // deduces std::deque<std::vector<int>::iterator>
    // first phase of overload resolution for list-initialization selects the candidate
    // synthesized from the initializer-list constructor; second phase is not performed
    // and deduction guide has no effect
    std::deque y{v.begin(), v.end()};
}

okay that’s the whole page, bestie 🫶. source: http://cppreference.com · version/date: 2024.06.10 · page: deductiongu...rstd::deque(3) — slay and goodbye 💋