home | help 
std::stack::stack(3)	       C++ Standard Libary	    std::stack::stack(3)

NAME
     std::stack::stack - std::stack::stack

Synopsis
	stack() : stack(Container()) {} 		    (1) (since C++11)
	explicit     stack(	const	  Container&	cont	=    Container()
     (until C++11)
	);
	explicit       stack(	    const	Container&	  cont	      );
     (since C++11)
	explicit    stack(    Container&&    cont   );			     (3)
     (since C++11)
	stack(	 const	 stack&    other    );				     (4)
     (implicitly
									      de-
     clared)
									      (since
     C++11)
	stack(	   stack&&    other    );				     (5)
     (implicitly
									      de-
     clared)
	template<    class    InputIt	 >				     (6)
     (since C++23)
	stack( InputIt first, InputIt last );
	template<     class    Alloc	>				     (7)
     (since C++11)
	explicit stack( const Alloc& alloc );
	template<    class    Alloc    >				     (8)
     (since C++11)
	stack( const Container& cont, const Alloc& alloc ); (2)
	template<     class    Alloc	>				     (9)
     (since C++11)
	stack( Container&& cont, const Alloc& alloc );
	template<    class    Alloc    >				    (10)
     (since C++11)
	stack( const stack& other, const Alloc& alloc );
	template<    class    Alloc    >				    (11)
     (since C++11)
	stack( stack&& other, const Alloc& alloc );
	template< class InputIt, class Alloc >
	stack(	InputIt  first,   InputIt   last,   const   Alloc&	    (12)
     (since C++23)
	alloc );
	template<     container-compatible-range<T>	R>		    (13)
     (since C++23)
	stack( std::from_range_t, R&& rg );
	template< container-compatible-range<T> R, class
	Alloc	    >							    (14)
     (since C++23)
	stack( std::from_range_t, R&& rg, const Alloc&
	alloc );

	Constructs  new underlying container of the container adaptor from a va-
     riety of data
	sources.

	1) Default constructor. Value-initializes the container.
	2) Copy-constructs the underlying container c with the contents of cont.
	This is also the default constructor.
	(until C++11)
	3) Move-constructs the underlying container c with std::move(cont).
	4) Copy constructor. The adaptor is copy-constructed with  the	contents
     of other.c.
	5) Move constructor. The adaptor is constructed with std::move(other.c).
	6) Constructs the underlying container c with the contents of the range
	[first, last). This overload participates in overload resolution only if
     InputIt
	satisfies LegacyInputIterator.
	7-12) These constructors participate in overload resolution only if
	std::uses_allocator<Container,	Alloc>::value  is  true, that is, if the
     underlying
	container is an allocator-aware container (true for all standard library
     containers
	that can be used with stack).
	7) Constructs the underlying container using alloc as allocator,  as  if
     by c(alloc).
	8) Constructs the underlying container with the contents of cont and us-
     ing alloc as
	allocator, as if by c(cont, alloc).
	9)  Constructs	the underlying container with the contents of cont using
     move
	semantics   while   utilizing	alloc	as   allocator,   as	if    by
     c(std::move(cont), alloc).
	10)  Constructs the adaptor with the contents of other.c and using alloc
     as
	allocator, as if by c(other.c, alloc).
	11) Constructs the adaptor with the contents of other using move  seman-
     tics while
	utilizing alloc as allocator, as if by c(std::move(other.c), alloc).
	12)  Constructs  the underlying container with the contents of the range
     [first, last)
	using alloc as allocator, as if by c(first, last, alloc). This	overload
     participates
	in overload resolution only if InputIt satisfies LegacyInputIterator.
	13) Constructs the underlying container with
	ranges::to<Container>(std::forward<R>(rg)).
	14) Constructs the underlying container with
	ranges::to<Container>(std::forward<R>(rg), alloc).

Parameters
	alloc		      - 	 allocator to use for all memory alloca-
     tions of the
					underlying container
	other		     -		another container adaptor to be used  as
     source to
					initialize the underlying container
	cont		      - 	  container to be used as source to ini-
     tialize the
					underlying container
	first, last	     -		range of elements [first, last) to  ini-
     tialize with
	rg		      - 	  a container compatible range, that is,
     an
					input_range whose elements are	convert-
     ible to T

Type requirements
	-
	Alloc must meet the requirements of Allocator.
	-
	Container must meet the requirements of Container. The constructors tak-
     ing an
	allocator parameter participate in overload resolution only if Container
     meets the
	requirements of AllocatorAwareContainer.
	-
	InputIt must meet the requirements of LegacyInputIterator.

Complexity
	Same as the corresponding operation on the wrapped container.

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
								    (6) and (12)
								    Ranges-aware
	__cpp_lib_containers_ranges		    202202L (C++23) construction
     and
								    insertion;
     overloads
								    (13)     and
     (14)

Example
     // Run this code

      #include <cassert>
      #include <deque>
      #include <iostream>
      #include <memory>
      #include <ranges>
      #include <stack>

      int main()
      {
	  std::stack<int> c1;
	  c1.push(5);
	  assert(c1.size() == 1);

	  std::stack<int> c2(c1);
	  assert(c2.size() == 1);

	  std::deque<int> deq{3, 1, 4, 1, 5};
	  std::stack<int> c3(deq); // overload (2)
	  assert(c3.size() == 5);

      # ifdef __cpp_lib_adaptor_iterator_pair_constructor
	  const auto il = {2, 7, 1, 8, 2};
	  std::stack<int> c4{il.begin(), il.end()}; // C++23, (6)
	  assert(c4.size() == 5);
      # endif

      # if __cpp_lib_containers_ranges >= 202202L
	  // C++23, overload (13)
	  auto c5 = std::stack(std::from_range_t, std::ranges::iota(0, 42));
	  assert(c5.size() == 42);

	  // the same effect with pipe syntax, internally uses overload (13)
	  auto c6 = std::ranges::iota(0, 42) | std::ranges::to<std::stack>();
	  assert(c6.size() == 42);

	  std::allocator<int> alloc;

	  // C++23, overload (14)
	  auto	c7 = std::stack(std::from_range_t, std::ranges::iota(0, 42), al-
     loc);
	  assert(c7.size() == 42);

	  // the same effect with pipe syntax, internally uses overload (14)
	  auto c8 = std::ranges::iota(0, 42)  |  std::ranges::to<std::stack>(al-
     loc);
	  assert(c8.size() == 42);
      # endif
      }

	Defect reports

	The  following	behavior-changing  defect  reports were applied retroac-
     tively to
	previously published C++ standards.

	  DR	Applied to	Behavior as published	    Correct behavior
	P0935R0 C++11	   default constructor was explicit made implicit

See also
	operator= assigns values to the container adaptor
		  (public member function)

http://cppreference.com 	   2024.06.10		    std::stack::stack(3)
home | help