RetroSearch Browse

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

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

public member function

<queue>

std::queue::queue

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

initialize (1)

explicit queue (const container_type& ctnr);

move-initialize (2)

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

allocator (3)

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

init + allocator (4)

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

move-init + allocator (5)

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

copy + allocator (6)

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

move + allocator (7)

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

Construct queue

Constructs a queue container adaptor object.

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.

Parameters

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 queue of the same type (i.e., with the same template arguments, T and Container).

Example

// constructing queues
#include <iostream>       // std::cout
#include <deque>          // std::deque
#include <list>           // std::list
#include <queue>          // std::queue

int main ()
{
  std::deque<int> mydeck (3,100);        // deque with 3 elements
  std::list<int> mylist (2,200);         // list with 2 elements

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

  std::queue<int,std::list<int> > third; // empty queue with list as underlying container
  std::queue<int,std::list<int> > fourth (mylist);

  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;
}

Output:

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

Complexity One container construction (which for standard containers is up to linear in its size).

Iterator validityMoving constructors (2) and (7), may invalidate all iterators, pointers and references related to their moved argument.

Data races All copied elements are accessed.
The moving constructors (2) and (7) may modify their (first) argument.

Exception safety Provides the same level of guarantees as the operation performed on the container.

See also

queue::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