Namespaces
Variants

std::priority_queue<T,Container,Compare>:: priority_queue

From cppreference.net
C++
Containers library
std::priority_queue
priority_queue ( ) : priority_queue ( Compare ( ) , Container ( ) ) { }
(1) (desde C++11)
explicit priority_queue ( const Compare & compare )
: priority_queue ( compare, Container ( ) ) { }
(2) (desde C++11)
(3)
explicit priority_queue ( const Compare & compare = Compare ( ) ,
const Container & cont = Container ( ) ) ;
(hasta C++11)
priority_queue ( const Compare & compare, const Container & cont ) ;
(desde C++11)
priority_queue ( const Compare & compare, Container && cont ) ;
(4) (desde C++11)
priority_queue ( const priority_queue & other ) ;
(5)
priority_queue ( priority_queue && other ) ;
(6) (desde C++11)
template < class InputIt >

priority_queue ( InputIt first, InputIt last,

const Compare & compare = Compare ( ) ) ;
(7) (desde C++11)
(8)
template < class InputIt >

priority_queue ( InputIt first, InputIt last,
const Compare & compare = Compare ( ) ,

const Container & cont = Container ( ) ) ;
(hasta C++11)
template < class InputIt >

priority_queue ( InputIt first, InputIt last,

const Compare & compare, const Container & cont ) ;
(desde C++11)
template < class InputIt >

priority_queue ( InputIt first, InputIt last,

const Compare & compare, Container && cont ) ;
(9) (desde C++11)
template < class Alloc >
explicit priority_queue ( const Alloc & alloc ) ;
(10) (desde C++11)
template < class Alloc >
priority_queue ( const Compare & compare, const Alloc & alloc ) ;
(11) (desde C++11)
template < class Alloc >

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

const Alloc & alloc ) ;
(12) (desde C++11)
template < class Alloc >

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

const Alloc & alloc ) ;
(13) (desde C++11)
template < class Alloc >
priority_queue ( const priority_queue & other, const Alloc & alloc ) ;
(14) (desde C++11)
template < class Alloc >
priority_queue ( priority_queue && other, const Alloc & alloc ) ;
(15) (desde C++11)
template < class InputIt, class Alloc >
priority_queue ( InputIt first, InputIt last, const Alloc & alloc ) ;
(16) (desde C++11)
template < class InputIt, class Alloc >

priority_queue ( InputIt first, InputIt last, const Compare & compare,

const Alloc & alloc ) ;
(17) (desde C++11)
template < class InputIt, class Alloc >

priority_queue ( InputIt first, InputIt last, const Compare & compare,

const Container & cont, const Alloc & alloc ) ;
(18) (desde C++11)
template < class InputIt, class Alloc >

priority_queue ( InputIt first, InputIt last, const Compare & compare,

Container && cont, const Alloc & alloc ) ;
(19) (desde C++11)
template < container-compatible-range < T > R >

priority_queue ( std:: from_range_t , R && rg,

const Compare & compare = Compare ( ) ) ;
(20) (desde C++23)
template < container-compatible-range < T > R, class Alloc >

priority_queue ( std:: from_range_t , R && rg,

const Compare & compare, const Alloc & alloc ) ;
(21) (desde C++23)
template < container-compatible-range < T > R, class Alloc >
priority_queue ( std:: from_range_t , R && rg, const Alloc & alloc ) ;
(22) (desde C++23)

Construye un nuevo contenedor subyacente del adaptador de contenedor a partir de diversas fuentes de datos.

1) Constructor por defecto. Inicializa por valor el comparador y el contenedor subyacente.
2) Construye por copia el funtor de comparación comp con el contenido de compare . Inicializa por valor el contenedor subyacente c .
3) Construye por copia el contenedor subyacente c con los contenidos de cont . Construye por copia el funtor de comparación comp con los contenidos de compare . Llama a std:: make_heap ( c. begin ( ) , c. end ( ) , comp ) . Este es también el constructor por defecto. (until C++11)
4) Construye por movimiento el contenedor subyacente c con std :: move ( cont ) . Construye por copia el funtor de comparación comp con compare . Llama a std:: make_heap ( c. begin ( ) , c. end ( ) , comp ) .
5) Constructor de copia . El contenedor subyacente se construye por copia con other. c . El funtor de comparación se construye por copia con other. comp . (declarado implícitamente)
6) Constructor de movimiento . El contenedor subyacente se construye con std :: move ( other. c ) . El funtor de comparación se construye con std :: move ( other. comp ) . (declarado implícitamente)
7-9) Constructores de pares de iteradores. Estas sobrecargas participan en la resolución de sobrecarga solo si InputIt satisface LegacyInputIterator .
7) Construye c como si fuera mediante c ( first, last ) y comp desde compare . Luego llama a std:: make_heap ( c. begin ( ) , c. end ( ) , comp ) ; .
8) Construye por copia c desde cont y comp desde compare . Luego llama a c. insert ( c. end ( ) , first, last ) ; , y posteriormente llama a std:: make_heap ( c. begin ( ) , c. end ( ) , comp ) ; .
9) Construye por movimiento c desde std :: move ( cont ) y construye por copia comp desde compare . Luego llama a c. insert ( c. end ( ) , first, last ) ; , y luego llama a std:: make_heap ( c. begin ( ) , c. end ( ) , comp ) ; .
10-15) Constructores extendidos con asignador. Estas sobrecargas participan en la resolución de sobrecarga solo si std:: uses_allocator < container_type, Alloc > :: value es true , es decir, si el contenedor subyacente es un contenedor consciente del asignador (verdadero para todos los contenedores de la biblioteca estándar).
10) Construye el contenedor subyacente usando alloc como asignador. Efectivamente llama a c ( alloc ) . comp es inicializado por valor.
11) Construye el contenedor subyacente usando alloc como asignador. Efectivamente llama c ( alloc ) . Copia-construye comp desde compare .
12) Construye el contenedor subyacente con el contenido de cont y utilizando alloc como asignador, como si fuera mediante c ( cont, alloc ) . Copia-construye comp desde compare . Luego llama a std:: make_heap ( c. begin ( ) , c. end ( ) , comp ) .
13) Construye el contenedor subyacente con el contenido de cont usando semántica de movimiento mientras utiliza alloc como asignador, como si fuera mediante c ( std :: move ( cont ) , alloc ) . Copia-construye comp desde compare . Luego llama a std:: make_heap ( c. begin ( ) , c. end ( ) , comp ) .
14) Construye el contenedor subyacente con el contenido de other. c y utilizando alloc como asignador. Efectivamente llama a c ( other. c , alloc ) . Construye por copia comp desde other. comp .
15) Construye el contenedor subyacente con el contenido de other usando semántica de movimiento mientras utiliza alloc como asignador. Efectivamente llama a c ( std :: move ( other. c ) , alloc ) . Construye por movimiento comp desde other. comp .
16-19) Constructores de par de iteradores extendidos con asignador. Igual que (7-9) , excepto que alloc se utiliza para construir el contenedor subyacente. Estas sobrecargas participan en la resolución de sobrecarga solo si std:: uses_allocator < container_type, Alloc > :: value es true e InputIt satisface LegacyInputIterator .
20) Inicializa comp con compare y c con ranges:: to < Container > ( std:: forward < R > ( rg ) ) . Luego llama a std:: make_heap ( c. begin ( ) , c. end ( ) , comp ) .
21) Inicializa comp con compare y c con ranges:: to < Container > ( std:: forward < R > ( rg ) , alloc ) . Luego llama a std:: make_heap ( c. begin ( ) , c. end ( ) , comp ) .
22) Inicializa c con ranges:: to < Container > ( std:: forward < R > ( rg ) , alloc ) . Luego llama a std:: make_heap ( c. begin ( ) , c. end ( ) , comp ) .

Tenga en cuenta que la forma en que una implementación verifica si un tipo satisface LegacyInputIterator no está especificada, excepto que se requiere que los tipos integrales sean rechazados.

Contenidos

Parámetros

alloc - asignador a utilizar para todas las asignaciones de memoria del contenedor subyacente
other - otro adaptador de contenedor que se utilizará como fuente para inicializar el contenedor subyacente
cont - contenedor que se utilizará como fuente para inicializar el contenedor subyacente
compare - el objeto función de comparación para inicializar el funtor de comparación subyacente
first, last - el par de iteradores que define el rango de elementos con los que inicializar
rg - un rango compatible con contenedor , es decir, un input_range cuyos elementos son convertibles a T
Requisitos de tipo
-
Alloc debe cumplir con los requisitos de Allocator .
-
Compare debe cumplir con los requisitos de Compare .
-
Container debe cumplir con los requisitos de Container . Los constructores extendidos con asignador solo se definen si Container cumple con los requisitos de AllocatorAwareContainer .
-
InputIt debe cumplir con los requisitos de LegacyInputIterator .

Complejidad

1,2) Constante.
3,5,12) O(N) comparaciones y O(N) llamadas al constructor de value_type , donde N es cont. size ( ) .
4) O(N) comparaciones, donde N es cont. size ( ) .
6) Constante.
7,16,17) O(M) comparaciones, donde M es std:: distance ( first, last ) .
8,18) O(N + M) comparaciones y O(N) llamadas al constructor de value_type , donde N es cont. size ( ) y M es std:: distance ( first, last ) .
9) O(N + M) comparaciones, donde N es cont. size ( ) y M es std:: distance ( first, last ) .
10,11) Constante.
13) O(N) comparaciones, donde N es cont. size ( ) .
14) Lineal en tamaño de other .
15) Constante si Alloc es igual al asignador de other . Lineal en el tamaño de other en caso contrario.
19) O(N + M) comparaciones y posiblemente O(N) llamadas al constructor de value_type (presente si Alloc no es igual al asignador de other ), donde N es cont. size ( ) y M es std:: distance ( first, last ) .
20) O(N) comparaciones y O(N) llamadas al constructor de value_type , donde N es ranges:: distance ( rg ) .
21,22)
Esta sección está incompleta

Notas

Macro de prueba de características Valor Std Característica
__cpp_lib_containers_ranges 202202L (C++23) Construcción e inserción con reconocimiento de rangos; sobrecargas ( 20-22 )

Ejemplo

Ejecutar este código 
#include <complex>
#include <functional>
#include <iostream>
#include <queue>
#include <vector>
int main()
{
    std::priority_queue<int> pq1;
    pq1.push(5);
    std::cout << "pq1.size() = " << pq1.size() << '\n';
    std::priority_queue<int> pq2 {pq1};
    std::cout << "pq2.size() = " << pq2.size() << '\n';
    std::vector<int> vec {3, 1, 4, 1, 5};
    std::priority_queue<int> pq3 {std::less<int>(), vec};
    std::cout << "pq3.size() = " << pq3.size() << '\n';
    for (std::cout << "pq3 : "; !pq3.empty(); pq3.pop())
        std::cout << pq3.top() << ' ';
    std::cout << '\n';
    // Demo With Custom Comparator:
    using my_value_t = std::complex<double>;
    using my_container_t = std::vector<my_value_t>;
    auto my_comp = [](const my_value_t& z1, const my_value_t& z2)
    {
        return z2.real() < z1.real();
    };
    std::priority_queue<my_value_t,
                        my_container_t,
                        decltype(my_comp)> pq4{my_comp};
    using namespace std::complex_literals;
    pq4.push(5.0 + 1i);
    pq4.push(3.0 + 2i);
    pq4.push(7.0 + 3i);
    for (; !pq4.empty(); pq4.pop())
    {
        const auto& z = pq4.top();
        std::cout << "pq4.top() = " << z << '\n';
    }
    // TODO: C++23 range-aware ctors
}

Salida: 

pq1.size() = 1
pq2.size() = 1
pq3.size() = 5
pq3 : 5 4 3 1 1
pq4.top() = (3,2)
pq4.top() = (5,1)
pq4.top() = (7,3)

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
P0935R0 C++11 el constructor por defecto y el constructor (4) eran explícitos se hicieron implícitos
LWG 3506 C++11 faltaban los constructores de par de iteradores extendidos con asignador añadidos
LWG 3522 C++11 faltaban las restricciones en los constructores de par de iteradores añadidas
LWG 3529 C++11 la construcción desde un par de iteradores llamaba a insert construye el contenedor a partir de ellos

Véase también

asigna valores al adaptador de contenedor
(función miembro pública)