std::priority_queue<T,Container,Compare>::priority_queue
De cppreference.com
<tbody>
</tbody>
<tbody class="t-dcl-rev t-dcl-rev-num ">
</tbody><tbody>
</tbody>
<tbody class="t-dcl-rev t-dcl-rev-num ">
</tbody><tbody>
</tbody>
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) |
Construye el nuevo contenedor subyacente del adaptador de contenedor a partir de una variedad de fuentes de datos.
1) Constructor por defecto. Inicializa el comparador y el contenedor subyacente.
2) Construye por copia el objeto función 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 el contenido de cont. Construye por copia el objeto función de comparación comp con el contenido de compare. Llama a std::make_heap(c.begin(), c.end(), comp). Este es también el constructor por defecto. (hasta C++11)4) Construye por movimiento el contenedor subyacente
c con std::move(cont). Construye por copia el objeto función 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 objeto función de comparación se construye por copia con other.comp. (implícitamente declarado)6) Constructor de movimiento. El contenedor subyacente se construye con
std::move(other.c). El objeto función de comparación se construye con std::move(other.comp). (implícitamente declarado)7-9) Constructores con un par de iteradores. Estas sobrecargas solo participan en la resolución de sobrecargas si
InputIt satisface InputIterator.7) Construye
c como si fuera por c(first, last) y comp de compare. Luego llama a std::make_heap(c.begin(), c.end(), comp);.8) Construye por copia
c de cont y comp de compare. Luego llama a c.insert(c.end(), first, last);, y luego llama a std::make_heap(c.begin(), c.end(), comp);.9) Construye por movimiento
c de std::move(cont) y construye por copia a comp de 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 un asignador de memoria. Estas sobrecargas solo participan en la resolución de sobrecargas si
std::uses_allocator<container_type, Alloc>::value es true, es decir, si el contenedor subyacente es un contenedor consciente de un asignador de memoria (true para todos los contenedores de la biblioteca estándar).10) Construye el contenedor subyacente y usa a
alloc como el asignador de memoria. Efectivamente llama a c(alloc). comp es inicializado por valor.11) Construye el contenedor subyacente y usa a
alloc como el asignador de memoria. Efectivamente llama a c(alloc). Construye por copia a comp de compare.12) Construye el contenedor subyacente con el contenido de
cont y usa a alloc como el asignador de memoria, como si fuera por c(cont, alloc). Construye por copia a comp de compare. Luego llama a std::make_heap(c.begin(), c.end(), comp). 13) Construye el contenedor subyacente con el contenido de
cont usando la semántica de movimiento y usa a alloc como el asignador de memoria, como si fuera por c(std::move(cont), alloc). Construye por copia a comp de compare. Luego llama a std::make_heap(c.begin(), c.end(), comp). 14) Construye el contenedor subyacente con el contenido de
other.c y usa a alloc como el asignador de memoria. Efectivamente llama a c(other.c, alloc). Construye por copia a comp de other.comp.15) Construye el contenedor subyacente con el contenido de
other usando la semántica de movimiento y usa a alloc como el asignador de memoria. Efectivamente llama a c(std::move(other.c), alloc). Construye por movimiento a comp de other.comp.16-19) Constructores extendidos con un par de iteradores y un asignador de memoria. Igual que (7-9), excepto que
alloc se usa para construir el contenedor subyacente. Estas sobrecargas solo participan en la resolución de sobrecargas si std::uses_allocator<container_type, Alloc>::value es true y InputIt satisface InputIterator.Toma en cuenta que no se especifica cómo una implmentación comprueba si un tipo satisface InputIterator, excepto que se requiere que se rechacen los tipos enteros.
Parámetros
| alloc | - | Asignador de memoria a usar para todas las asignaciones de memoria del contenedor subyacente. |
| other | - | Otro adaptador de contenedor a usar como fuente para inicializar el contenedor subyacente. |
| cont | - | Contenedor a usar como fuente para inicializar el contenedor subyacente. |
| compare | - | El objeto función de comparación para inicializar el objeto función de comparación subyacente. |
| first, last | - | Rango de elementos con el cual inicializar. |
| Requisitos de tipo | ||
-Alloc debe satisfacer los requisitos de Allocator.
| ||
-Container debe satisfacer los requisitos de Container. Los constructores extendidos con un asignador de memoria solo se definen si Container cumple con los requerimientos de AllocatorAwareContainer
| ||
-InputIt debe satisfacer los requisitos de InputIterator.
| ||
Complejidad
1-2) Constante.
3,5) O(N) comparaciones y O(N) llama 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) llama al constructor de
value_type, donde N y M son cont.size() y std::distance(first, last) respectivamente.9) O(N) comparaciones, donde N es
cont.size() + std::distance(first, last).10-11) Constante.
12) O(N) comparaciones y O(N) llama al constructor de
value_type, donde N es cont.size().13) O(N) comparaciones, donde N es
cont.size().14) Lineal en el tamaño de
other.15) Constante si
Alloc se compara igual al asignador de memoria de other. Lineal en el tamaño de other de lo contrario.19) O(N+M) comparaciones y posiblemente presente O(N) llama al constructor de
value_type (presente si Alloc no se compara igual al asignador de memoria de other), donde N y M son cont.size() y std::distance(first, last) respectivamente. Ejemplo
Ejecuta 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';
// Demostración con comparador personalizado:
using mi_valor_t = std::complex<double>;
using mi_contenedor_t = std::vector<mi_valor_t>;
auto mi_comparador = [](const mi_valor_t& z1, const mi_valor_t& z2) {
return z2.real() < z1.real();
};
std::priority_queue<mi_valor_t,
mi_contenedor_t,
decltype(mi_comparador)> pq4 {mi_comparador};
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';
}
}
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 de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.
| ID | Aplicado a | Comportamiento según lo publicado | Comportamiento correcto |
|---|---|---|---|
| P0935R0 | C++11 | El constructor por defecto y el constructor (4) eran explicit.
|
Se hicieron implícitos |
| LWG 3506 | C++11 | Faltaban los constructores extendidos con un asignador y un par de iteradores. | Se agregaron. |
| LWG 3522 | C++11 | Faltaban las restricciones para los constructores con un par de iteradores. | Se agregaron. |
| LWG 3529 | C++11 | La construcción a partir de 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) |