std::priority_queue::priority_queue

 

C++

Language

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

 

Containers library

array (C++11)

vector

deque

forward_list (C++11)

list

set

multiset

map

multimap

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

stack

queue

priority_queue

 

std::priority_queue

Member functions

priority_queue::priority_queue

priority_queue::~priority_queue

priority_queue::operator=

Element access

priority_queue::top

Capacity

priority_queue::empty

priority_queue::size

Modifiers

priority_queue::push

priority_queue::emplace

priority_queue::pop

priority_queue::swap

 

explicit priority_queue( const Compare& compare = Compare(),                          const Container& cont = Container()); priority_queue( const Compare& compare, const Container& cont);	(1)	(until C++11) (since C++11)
explicit priority_queue( const Compare& compare = Compare(),                          Container&& cont = Container());	(2)	(since C++11)
priority_queue( const priority_queue& other );	(3)
priority_queue( priority_queue&& other );	(4)	(since C++11)
template< class Allocator > explicit priority_queue( const Allocator& alloc );	(5)	(since C++11)
template< class Allocator > priority_queue( const Compare& compare, const Allocator& alloc );	(6)	(since C++11)
template< class Allocator > priority_queue( const Compare& compare, const Container& cont,                 const Allocator& alloc );	(7)	(since C++11)
template< class Allocator > priority_queue( const Compare& compare, Container&& cont,                 const Allocator& alloc );	(8)	(since C++11)
template< class Allocator > priority_queue( const priority_queue& other, const Allocator& alloc );	(9)	(since C++11)
template< class Allocator > priority_queue( priority_queue&& other, const Allocator& alloc );	(10)	(since C++11)
template< class InputIterator > priority_queue( InputIterator first, InputIterator last,                 const Compare& compare, const Container& cont );	(11)	(since C++11)
template< class InputIterator > priority_queue(InputIterator first, InputIterator last,                const Compare& compare = Compare(), Container&& cont = Container());	(12)	(since C++11)

Constructs new underlying container of the container adaptor from a variety of data sources.

1) Copy-constructs the underlying container c with the contents of cont. Copy-constructs the comparison functor comp with the contents of compare. Calls std::make_heap(c.begin(), c.end(), comp). This is also the default constructor (until C++11)

2) Move-constructs the underlying container c with std::move(cont). Move-constructs the comparison functor comp with std::move(compare). Calls std::make_heap(c.begin(), c.end(), comp). This is also the default constructor (since C++11)

3) Copy constructor. The adaptor is copy-constructed with the contents of other.c. The comparison functor is constructed with std::move(other.comp). (implicitly declared)

4) Move constructor. The adaptor is constructed with std::move(other.c). The comparison functor is constructed with std::move(other.comp). (implicitly declared)

The constructors 5..10 are only defined if std::uses_allocator<container_type, Alloc>::value == true, that is, if the underlying container is an allocator-aware container (true for all standard library containers).

5) Constructs the underlying container using alloc as allocator. Effectively calls c(alloc). comp is value-initialized.

6) Constructs the underlying container using alloc as allocator. Effectively calls c(alloc). Copy-constructs comp from compare.

7) Constructs the underlying container with the contents of cont and using alloc as allocator. Effectively calls c(cont, alloc). Copy-constructs comp from compare.

8) Constructs the underlying container with the contents of cont using move semantics while utilising alloc as allocator. Effectively calls c(std::move(cont), alloc). Copy-constructs comp from compare.

9) Constructs the adaptor with the contents of other.c and using alloc as allocator. Effectively calls c(athor.c, alloc). Copy-constructs comp from other.comp.

10) Constructs the adaptor with the contents of other using move semantics while utilising alloc as allocator. Effectively calls c(std::move(other.c), alloc). Move-constructs comp from other.comp.

11) Copy-constructs c from cont and comp from compare. Then calls c.insert(c.end(), first, last);, and then calls std::make_heap(c.begin(), c.end(), comp);.

12) Move-constructs c from std::move(cont) and comp from std::move(compare). Then calls c.insert(c.end(), first, last);, and then calls std::make_heap(c.begin(), c.end(), comp);.

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 container
cont	-	container to be used as source to initialize the underlying container
compare	-	the comparison function object to initialize the underlying comparison functor
first	-	InputIterator pointing at the beginning of the initialization sequence
last	-	InputIterator pointing one past the end of the initialization sequence

Complexity

1, 3, 5, 6, 8: linear in cont or other

2, 4, 7, 9: constant

Example

#include <queue>
#include <deque>
#include <iostream>
 
int main()
{
    std::priority_queue<int> c1;
    c1.push(5);
    std::cout << c1.size() << '\n';
 
    std::priority_queue<int> c2(c1);
    std::cout << c2.size() << '\n';
 
    std::deque<int> deq {3, 1, 4, 1, 5};
    std::priority_queue<int> c3(std::less<int>(),deq);
    std::cout << c3.size() << '\n';
}

Output:

1
1
5

See also

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