Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://cplusplus.com/reference/stack/stack/stack/ below:

public member function

<stack>

explicit stack (const container_type& ctnr = container_type());

explicit stack (const container_type& ctnr);

explicit stack (container_type&& ctnr = container_type());

template <class Alloc> explicit stack (const Alloc& alloc);

template <class Alloc> stack (const container_type& ctnr, const Alloc& alloc);

template <class Alloc> stack (container_type&& ctnr, const Alloc& alloc);

template <class Alloc> stack (const stack& x, const Alloc& alloc);

template <class Alloc> stack (stack&& x, const Alloc& alloc);

Construct stack

A container adaptor keeps internally a container object as data. This container object is a copy of the ctnr argument passed to the constructor, if any, otherwise it is an empty container.

A container adaptor keeps internally a container object as data, which is initialized by this constructor:

(1) initialization constructor

Constructs a container adaptor whose internal container is initialized to a copy of ctnr.

(2) move-initialization constructor

Constructs a container adaptor whose internal container acquires the value of ctnr by move-constructing it.

(3) allocator constructor

Constructs a container adaptor whose internal container is constructed with alloc as argument.

(4) initialization with allocator constructor

Constructs a container adaptor whose internal container is constructed with cntr and alloc as arguments.

(5) move-initialization with allocator constructor

Constructs a container adaptor whose internal container is constructed with std::move(cntr) and alloc as arguments.

(6) copy with allocator constructor

Constructs a container adaptor whose internal container is constructed with x's internal container as first argument and alloc as second.

(7) move with allocator constructor

Constructs a container adaptor whose internal container is constructed by moving x's internal container as first argument and passing alloc as second.

ctnr

Container object.
container_type is the type of the underlying container type (defined as an alias of the second class template parameter, Container; see member types).

alloc

Allocator object.
Alloc shall be a type for which uses_allocator::value is true (for other types, the constructor does not even participate in overload resolution).

x

A stack of the same type (i.e., with the same template arguments, T and Container).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// constructing stacks
#include <iostream>       // std::cout
#include <stack>          // std::stack
#include <vector>         // std::vector
#include <deque>          // std::deque

int main ()
{
  std::deque<int> mydeque (3,100);          // deque with 3 elements
  std::vector<int> myvector (2,200);        // vector with 2 elements

  std::stack<int> first;                    // empty stack
  std::stack<int> second (mydeque);         // stack initialized to copy of deque

  std::stack<int,std::vector<int> > third;  // empty stack using vector
  std::stack<int,std::vector<int> > fourth (myvector);

  std::cout << "size of first: " << first.size() << '\n';
  std::cout << "size of second: " << second.size() << '\n';
  std::cout << "size of third: " << third.size() << '\n';
  std::cout << "size of fourth: " << fourth.size() << '\n';

  return 0;
}

size of first: 0
size of second: 3
size of third: 0
size of fourth: 2

stack::push

Insert element (public member function)

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4