deductiongu...rstd::stack(3)

💖 NAME 💖

okay so bestie, welcome to deductiongu...rstd::stack(3) — straight outta the C++ Standard Libary (yes, that's how the header spells it 💀). This page is literally the deduction-guide glow-up for std::stack.

The name is a mouthful: deductionguidesforstd::stack — and the official one-liner is deductionguidesforstd::stack - deductionguidesforstd::stack. no cap, that's the whole NAME vibe. ✨

✨ SYNOPSIS ✨

Defined in header <stack>:

template< class Container >
stack( Container )
(1) (since C++17)
    -> stack<typename Container::value_type, Container>;

template< class Container, class Alloc >
stack( Container, Alloc )
(2) (since C++17)
    -> stack<typename Container::value_type, Container>;

template< class InputIt >
stack( InputIt, InputIt )
(3) (since C++23)
    -> stack<typename std::iterator_traits<InputIt>::value_type>;

template< class InputIt, class Alloc >
stack( InputIt, InputIt, Alloc )
(4) (since C++23)
    -> stack<typename std::iterator_traits<InputIt>::value_type,
             std::deque<typename std::iterator_traits<InputIt>::value_type, Alloc>>;

template< ranges::input_range R >
stack( std::from_range_t, R&& )
(5) (since C++23)
    -> stack<ranges::range_value_t<R>>;

template< ranges::input_range R, class Allocator >
stack( std::from_range_t, R&&, Allocator )
(6) (since C++23)
    -> stack<ranges::range_value_t<R>,
             std::deque<ranges::range_value_t<R>, Allocator>>;

These deduction guides are provided for stack to allow deduction from underlying container type. 💅

1. Deduces underlying container type from the argument.
2. Same as (1), except that the allocator is provided.
3. Deduces the element type from the iterator, using std::deque<typename std::iterator_traits<InputIt>::value_type> as the underlying container type.
4. Same as (3), except that the allocator is provided.
5. Deduces the element type from a std::from_range_t tag and an input_range.
6. Same as (5), except that the allocator is provided.

These overloads participate in overload resolution only if:

• InputIt (if exists) satisfies LegacyInputIterator,
• Container (if exists) does not satisfy Allocator,
• for (3) (until C++23) (4) (since C++23), Alloc satisfies Allocator, and
• std::uses_allocator_v<Container, Alloc> is true if both Container and Alloc exist.

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. 🫶

🧠 NOTES 🧠

Feature-test macro tea, bestie ☕ — here's the whole table vibe:

• __cpp_lib_adaptor_iterator_pair_constructor — value 202106L, std (C++23), feature: Iterator pair constructors for std::queue and std::stack; overloads (2) and (4).
• __cpp_lib_containers_ranges — value 202202L, std (C++23), feature: Ranges-aware construction and insertion; overloads (5) and (6).

🌈 EXAMPLE 🌈

// Run this code

#include <stack>
#include <vector>

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

and that's the whole flex — guide #1 literally deduces std::stack<int, vector<int>> from std::stack s{v};. iconic. 👑

mwah 💋 — source: http://cppreference.com, version/date: 2024.06.10, page: deductiongu...rstd::stack(3). bye bestie, go deduce something cute 🎀