Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

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 con-
       tainer 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 Con-
       tainer 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 inte-
       gral types do not
	  qualify as input iterators. Likewise,	the extent to which it	deter-
       mines 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
       Feature
								      Iterator
       pair
								      con-
       structors 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)	  con-
       struction and
								      inser-
       tion; 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)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=deductionguidesforstd::queue&sektion=3&manpath=FreeBSD+Ports+15.1.quarterly>

home | help