home | help 
deductiongu...rstd::queue(3)   C++ Standard Libary  deductiongu...rstd::queue(3)

NAME
     deductionguidesforstd::queue - deductionguidesforstd::queue

Synopsis
	Defined in header <queue>
	template< class Container >

	queue(	Container  )						     (1)
     (since C++17)

	    -> queue<typename Container::value_type, Container>;
	template< class Container, class Alloc >

	queue( Container, Alloc  )					     (2)
     (since C++17)

	    -> queue<typename Container::value_type, Container>;
	template< class InputIt >

	queue(	InputIt,  InputIt )					     (3)
     (since C++23)

	    -> queue<typename std::iterator_traits<InputIt>::value_type>;
	template< class InputIt, class Alloc >

	queue( InputIt, InputIt, Alloc )
	    -> queue<typename  std::iterator_traits<InputIt>::value_type,    (4)
     (since C++23)

	       std::deque<typename
	std::iterator_traits<InputIt>::value_type, Alloc>>;
	template< ranges::input_range R >

	queue(	std::from_range_t,  R&& )				     (5)
     (since C++23)

	    -> queue<ranges::range_value_t<R>>;
	template< ranges::input_range R, class Allocator >

	queue( std::from_range_t, R&&, Allocator  )			     (6)
     (since C++23)
	    -> queue<ranges::range_value_t<R>,

	       std::deque<ranges::range_value_t<R>, Allocator>>;

	These  deduction  guides  are provided for queue 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 in-
     put_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		     Value    Std	    Fea-
     ture
								    Iterator
     pair
								    constructors
     for
	__cpp_lib_adaptor_iterator_pair_constructor 202106L  (C++23)  std::queue
     and
								    std::stack;
     overloads
								    (2) and (4)
								    Ranges-aware
	__cpp_lib_containers_ranges		    202202L (C++23) construction
     and
								    insertion;
     overloads (5)
								    and (6)

Example
     // Run this code

      #include <queue>
      #include <vector>

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

http://cppreference.com 	   2024.06.10	    deductiongu...rstd::queue(3)
home | help