deduction guides for std::priority_queue

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Metaprogramming library (C++11)

Diagnostics library

General utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library (C++17)

Regular expressions library (C++11)

Concurrency support library (C++11)

Execution support library (C++26)

Technical specifications

Symbols index

External libraries

 

Containers library

Sequence

array (C++11)

vector

vector<bool>

inplace_vector (C++26)

deque

forward_list (C++11)

list

Associative

set

multiset

map

multimap

Unordered associative

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

Adaptors

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

Views

span (C++20)

mdspan (C++23)

Tables

Iterator invalidation

Member function table

Non-member function table

 

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::push_range (C++23)

priority_queue::emplace (C++11)

priority_queue::pop

priority_queue::swap (C++11)

Non-member functions

swap(std::priority_queue) (C++11)

Helper classes

uses_allocator<std::priority_queue> (C++11)

formatter<std::priority_queue> (C++23)

Deduction guides(C++17)

 

Defined in header <queue>
template <class Comp, class Container> priority_queue(Comp, Container)  -> priority_queue<typename Container::value_type, Container, Comp>;	(1)	(since C++17)
template<class InputIt,          class Comp = std::less</*iter-value-type*/<InputIt>>,          class Container = std::vector</*iter-value-type*/<InputIt>> priority_queue(InputIt, InputIt, Comp = Comp(), Container = Container())   -> priority_queue</*iter-value-type*/<InputIt>, Container, Comp>;	(2)	(since C++17)
template<class Comp, class Container, class Alloc> priority_queue(Comp, Container, Alloc)   -> priority_queue<typename Container::value_type, Container, Comp>;	(3)	(since C++17)
template<class InputIt, class Alloc> priority_queue(InputIt, InputIt, Alloc)   -> priority_queue</*iter-value-type*/<InputIt>,                     std::vector</*iter-value-type*/<InputIt>, Alloc>,                     std::less</*iter-value-type*/<InputIt>>>;	(4)	(since C++17)
template<class InputIt, class Comp, class Alloc> priority_queue(InputIt, InputIt, Comp, Alloc)   -> priority_queue</*iter-value-type*/<InputIt>,                     std::vector</*iter-value-type*/<InputIt>, Alloc>, Comp>;	(5)	(since C++17)
template<class InputIt, class Comp, class Container, class Alloc> priority_queue(InputIt, InputIt, Comp, Container, Alloc)   -> priority_queue<typename Container::value_type, Container, Comp>;	(6)	(since C++17)

These deduction guides are provided for std::priority_queue to allow deduction from underlying container type and from an iterator range. /*iter-value-type*/<It> denotes typename std::iterator_traits<It>::value_type for any type It.

These overloads participate in overload resolution only if InputIt satisfies LegacyInputIterator, Comp does not satisfy Allocator, Container does not satisfy Allocator, for overloads (4) and (5),(since C++23) Alloc satisfies Allocator, and for overloads (3) and (6), std::uses_allocator_v<Container, Alloc> is true.

Note: the extent to which the library determines that a type does not satisfy LegacyInputIterator is unspecified, except that as a minimum integral types do not qualify as input iterators. Likewise, the extent to which it determines that a type does not satisfy Allocator is unspecified, except that as a minimum the member type Alloc::value_type must exist and the expression std::declval<Alloc&>().allocate(std::size_t{}) must be well-formed when treated as an unevaluated operand.

Example

Run this code

#include <functional>
#include <vector>
#include <queue>
int main() {
   std::vector<int> v = {1,2,3,4};
   std::priority_queue pq1{std::greater<int>{}, v}; // deduces std::priority_queue<
                                                    //   int, std::vector<int>,
                                                    //   std::greater<int>>
   std::priority_queue pq2{v.begin(), v.end()}; // deduces std::priority_queue<int>
}

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR	Applied to	Behavior as published	Correct behavior
LWG 3506	C++17	deduction guides from iterator and allocator were missing	added