Namespaces
Variants
Views
Actions

Difference between revisions of "cpp/container/priority queue/priority queue"

From cppreference.com
m (r2.7.3) (Robot: Adding de, fr, it, pt, zh)
Line 106: Line 106:
 
  | code=
 
  | code=
 
#include <queue>
 
#include <queue>
−
#include <deque>
+
#include <vector>
 
#include <iostream>
 
#include <iostream>
 +
#include <functional>
  
 
int main()
 
int main()
Line 118: Line 119:
 
     std::cout << c2.size() << '\n';
 
     std::cout << c2.size() << '\n';
 
   
 
   
−
     std::deque<int> deq {3, 1, 4, 1, 5};
+
     std::vector<int> vec={3, 1, 4, 1, 5};
−
     std::priority_queue<int> c3(std::less<int>(), deq);
+
     std::priority_queue<int> c3(std::less<int>(), vec);
 
     std::cout << c3.size() << '\n';
 
     std::cout << c3.size() << '\n';
 
}
 
}

Revision as of 04:41, 15 January 2013

 
C++
 
Containers library
 
std::priority_queue
 

Template:ddcl list begin <tr class="t-dcl ">

<td >
explicit priority_queue( const Compare& compare = Compare(),

                         const Container& cont = Container());

priority_queue( const Compare& compare, const Container& cont);
</td>

<td > (1) </td> <td > (until C++11)

(since C++11) </td> </tr> <tr class="t-dcl ">

<td >
explicit priority_queue( const Compare& compare = Compare(),
                         Container&& cont = Container());
</td>

<td > (2) </td> <td > (since C++11) </td> </tr> <tr class="t-dcl ">

<td >
priority_queue( const priority_queue& other );
</td>

<td > (3) </td> <td class="t-dcl-nopad"> </td> </tr> <tr class="t-dcl ">

<td >
priority_queue( priority_queue&& other );
</td>

<td > (4) </td> <td > (since C++11) </td> </tr> <tr class="t-dcl ">

<td >
template< class Alloc >
explicit priority_queue( const Alloc& alloc );
</td>

<td > (5) </td> <td > (since C++11) </td> </tr> <tr class="t-dcl ">

<td >
template< class Alloc >
priority_queue( const Compare& compare, const Alloc& alloc );
</td>

<td > (6) </td> <td > (since C++11) </td> </tr> <tr class="t-dcl ">

<td >
template< class Alloc >

priority_queue( const Compare& compare, const Container& cont,

                const Alloc& alloc );
</td>

<td > (7) </td> <td > (since C++11) </td> </tr> <tr class="t-dcl ">

<td >
template< class Alloc >

priority_queue( const Compare& compare, Container&& cont,

                const Alloc& alloc );
</td>

<td > (8) </td> <td > (since C++11) </td> </tr> <tr class="t-dcl ">

<td >
template< class Alloc >
priority_queue( const priority_queue& other, const Alloc& alloc );
</td>

<td > (9) </td> <td > (since C++11) </td> </tr> <tr class="t-dcl ">

<td >
template< class Alloc >
priority_queue( priority_queue&& other, const Alloc& alloc );
</td>

<td > (10) </td> <td > (since C++11) </td> </tr> <tr class="t-dcl ">

<td >
template< class InputIt >

priority_queue( InputIt first, InputIt last,

                const Compare& compare, const Container& cont );
</td>

<td > (11) </td> <td > (since C++11) </td> </tr> <tr class="t-dcl ">

<td >
template< class InputIt >

priority_queue(InputIt first, InputIt last,

               const Compare& compare = Compare(), Container&& cont = Container());
</td>

<td > (12) </td> <td > (since C++11) </td> </tr> Template:ddcl list end

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)
5-10) The following constructors 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);.

Contents

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, 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 (5-10) are only defined if Container meets the requirements of Template:concept
-
InputIt must meet the requirements of LegacyInputIterator.

Complexity

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

2, 4, 7, 9: constant

This section is incomplete

Example

Run this code
#include <queue>
#include <vector>
#include <iostream>
#include <functional>
 
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::vector<int> vec={3, 1, 4, 1, 5};
    std::priority_queue<int> c3(std::less<int>(), vec);
    std::cout << c3.size() << '\n';
}

Output: 

1
1
5

See also

Template:cpp/container/dcl list operator=
Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/container/priority_queue/priority_queue&oldid=45753"