Namespaces
Variants

deduction guides for std::priority_queue

From cppreference.net
C++
Containers library
std::priority_queue
Défini dans l'en-tête <queue>
template < class Comp, class Container >

priority_queue ( Comp, Container )

- > priority_queue < typename Container :: value_type , Container, Comp > ;
(1) (depuis C++17)
template < class InputIt,

class Comp = std:: less < /*iter-val-t*/ < InputIt >> ,
class Container = std:: vector < /*iter-val-t*/ < InputIt > >
priority_queue ( InputIt, InputIt, Comp = Comp ( ) , Container = Container ( ) )

- > priority_queue < /*iter-val-t*/ < InputIt > , Container, Comp > ;
(2) (depuis C++17)
template < class Comp, class Container, class Alloc >

priority_queue ( Comp, Container, Alloc )

- > priority_queue < typename Container :: value_type , Container, Comp > ;
(3) (depuis C++17)
template < class InputIt, class Alloc >

priority_queue ( InputIt, InputIt, Alloc )
- > priority_queue < /*iter-val-t*/ < InputIt > ,
std:: vector < /*iter-val-t*/ < InputIt > , Alloc > ,

std:: less < /*iter-val-t*/ < InputIt >>> ;
(4) (depuis C++17)
template < class InputIt, class Comp, class Alloc >

priority_queue ( InputIt, InputIt, Comp, Alloc )
- > priority_queue < /*iter-val-t*/ < InputIt > ,

std:: vector < /*iter-val-t*/ < InputIt > , Alloc > , Comp > ;
(5) (depuis 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) (depuis C++17)
template < ranges:: input_range R,

class Comp = std:: less < ranges:: range_value_t < R >> >
priority_queue ( std:: from_range_t , R && , Comp = Comp ( ) )
- > priority_queue < ranges:: range_value_t < R > ,

std:: vector < ranges:: range_value_t < R >> , Comp > ;
(7) (depuis C++23)
template < ranges:: input_range R, class Comp, class Alloc >

priority_queue ( std:: from_range_t , R && , Comp, Alloc )
- > priority_queue < ranges:: range_value_t < R > ,

std:: vector < ranges:: range_value_t < R > , Alloc > , Comp > ;
(8) (depuis C++23)
template < ranges:: input_range R, class Alloc >

priority_queue ( std:: from_range_t , R && , Alloc )
- > priority_queue < ranges:: range_value_t < R > ,

std:: vector < ranges:: range_value_t < R > , Alloc >> ;
(9) (depuis C++23)
Alias de types d'aide uniquement d'exposition
template < class InputIt >

using /*iter-val-t*/ =

typename std:: iterator_traits < InputIt > :: value_type ;
( exposition uniquement* )

Les guides de déduction suivants suivants sont fournis pour std::priority_queue :

1-6) Permettre la déduction à partir du type de conteneur sous-jacent et d'une plage d'itérateurs.
7-9) Permettre la déduction à partir d'un std::from_range_t tag et d'un input_range .

Ces surcharges participent à la résolution de surcharge seulement si

Note : la mesure dans laquelle la bibliothèque détermine qu'un type ne satisfait pas LegacyInputIterator n'est pas spécifiée, sauf qu'au minimum les types entiers ne se qualifient pas comme itérateurs d'entrée. De même, la mesure dans laquelle elle détermine qu'un type ne satisfait pas Allocator n'est pas spécifiée, sauf qu'au minimum le type membre Alloc::value_type doit exister et l'expression std:: declval < Alloc & > ( ) . allocate ( std:: size_t { } ) doit être bien formée lorsqu'elle est traitée comme un opérande non évalué.

Notes

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_containers_ranges 202202L (C++23) Construction et insertion compatibles avec les gammes ; surcharges ( 7-9 )

Exemple

Exécuter ce code 
#include <functional>
#include <iostream>
#include <queue>
#include <vector>
int main()
{
    const std::vector<int> v = {1, 2, 3, 4};
    std::priority_queue pq1{std::greater<int>{}, v}; // déduit std::priority_queue<
                                                     //     int, std::vector<int>,
                                                     //     std::greater<int>>
    for (; !pq1.empty(); pq1.pop())
        std::cout << pq1.top() << ' ';
    std::cout << '\n';
    std::priority_queue pq2{v.begin(), v.end()}; // déduit std::priority_queue<int>
    for (; !pq2.empty(); pq2.pop())
        std::cout << pq2.top() << ' ';
    std::cout << '\n';
}

Sortie : 

1 2 3 4
4 3 2 1

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement corrigé
LWG 3506 C++17 les guides de déduction depuis l'itérateur et l'allocateur étaient manquants ajoutés, ( 4-6 )