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

FreeBSD Manual Pages

  
 
  

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)
	  stack(   stack&&   other   );					   (5)
       (since C++11)
	  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   >				     (2)   (8)
       (since C++11)
	  stack( const Container& cont,	const Alloc& alloc );
	  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	);

	  Constructs  new underlying container of the container	adaptor	from a
       variety 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 con-
       tents 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 In-
       putIt 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 li-
       brary 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
       using alloc as
	  allocator, as	if by c(cont, alloc).
	  9) Constructs	the underlying container with the contents of cont us-
       ing 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 se-
       mantics 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 over-
       load participates
	  in  overload	resolution only	if InputIt satisfies LegacyInputItera-
       tor.

Parameters
	  alloc			-	    allocator to use  for  all	memory
       allocations of the
					    underlying container
	  other			 -	      another  container adaptor to be
       used as source to
					    initialize	the  underlying	  con-
       tainer
	  cont			 -	     container to be used as source to
       initialize the
					    underlying container
	  first, last		-	    range of  elements	to  initialize
       with

Type requirements
	  -
	  Alloc	must meet the requirements of Allocator.
	  -
	  Container  must meet the requirements	of Container. The constructors
       taking an
	  allocator parameter participate in overload resolution only if  Con-
       tainer 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: __cpp_lib_adaptor_iterator_pair_constructor (for
       overloads (6)
			      and (12))

Example
       // Run this code

	#include <stack>
	#include <deque>
	#include <iostream>

	int main()
	{
	    std::stack<int> c1;
	    c1.push(5);
	    std::cout << c1.size() << '\n';

	    std::stack<int> c2(c1);
	    std::cout << c2.size() << '\n';

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

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

Possible output:
	1
	1
	5
	5

	 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		  2022.07.31		  std::stack::stack(3)

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

home | help