Przestrzenie nazw
Warianty

    std::priority_queue::priority_queue

    Z cppreference.com
     
    C++
     
    Kontenery
     
    std::priority_queue
     
    <tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody>
    (1)
    explicit priority_queue( const Compare& compare = Compare(), const Container& cont = Container() );
    		 (do C++11)
    priority_queue( const Compare& compare, const Container& cont );
    		 (od C++11)
    explicit priority_queue( const Compare& compare = Compare(), Container&& cont = Container() );
    		 (2) (od C++11)
    priority_queue( const priority_queue& other );
    		 (3)
    priority_queue( priority_queue&& other );
    		 (4) (od C++11)
    template< class Alloc > explicit priority_queue( const Alloc& alloc );
    		 (5) (od C++11)
    template< class Alloc > priority_queue( const Compare& compare, const Alloc& alloc );
    		 (6) (od C++11)
    template< class Alloc > priority_queue( const Compare& compare, const Container& cont, const Alloc& alloc );
    		 (7) (od C++11)
    template< class Alloc > priority_queue( const Compare& compare, Container&& cont, const Alloc& alloc );
    		 (8) (od C++11)
    template< class Alloc > priority_queue( const priority_queue& other, const Alloc& alloc );
    		 (9) (od C++11)
    template< class Alloc > priority_queue( priority_queue&& other, const Alloc& alloc );
    		 (10) (od C++11)
    template< class InputIt > priority_queue( InputIt first, InputIt last, const Compare& compare, const Container& cont );
    		 (11) (od C++11)
    template< class InputIt > priority_queue( InputIt first, InputIt last, const Compare& compare = Compare(), Container&& cont = Container() );
    		 (12) (od C++11)

    Konstruuje nowy kontener opakowywany przez ten adapter z różnych źródeł danych, opcjonalnie wykorzystując dostarczony przez użytkownika alokator alloc i/lub obiekt funkcji porównującej comp.

    1) Konstruuje opakowywany kontener c poprzez skopiowanie cont. Konstruuje funktor porównujący comp poprzez skopiowanie compare. Wywołuje std::make_heap(c.begin(), c.end(), comp). Jest to również konstruktor domyślny. (do C++11)
    2) Konstruuje opakowywany kontener c poprzez przeniesienie std::move(cont). Konstruuje funktor porównujący comp poprzez skopiowanie compare. Wywołuje std::make_heap(c.begin(), c.end(), comp). Jest to również konstruktor domyślny. (od C++11)
    3) Konstruktor kopiujący. Adapter jest konstruowany poprzez skopiowanie other.c. Funktor porównujący jest konstruowany za pomocą std::move(other.comp). (niejawnie zadeklarowany)
    4) Konstruktor przenoszący. Adapter jest konstruowany poprzez przeniesienie std::move(other.c). Funktor porównujący jest konstruowany za pomocą std::move(other.comp). (niejawnie zadeklarowany)
    5-10) Następujące konstruktory są zdefiniowane tylko wtegy, gdy std::uses_allocator<container_type, Alloc>::value == true, to znaczy, gdy opakowywany kontener jest "allocator-aware" (wszystkie kontenery biblioteki standardowej spełniają to założenie).
    5) Konstruuje opakowywany kontener, wykorzystując alloc jako alokator. W rzeczywistości wywołuje c(alloc). comp is value-initialized.
    6) Konstruuje opakowywany kontener, wykorzystując alloc jako alokator. W rzeczywistości wywołuje c(alloc). Konstruuje comp poprzez skopiowanie compare.
    7) Konstruuje opakowywany kontener wykorzystując zawartość cont i używając alloc jako alokatora, tak jak przy wywołaniu c(cont, alloc). Konstruuje comp przez skopiowanie compare. Następnie wywołuje std::make_heap(c.begin(), c.end(), comp).
    8) Konstruuje opakowywany kontener przenosząc zawartość cont i używając alloc jako alokatora, tak jak przy wywołaniu c(std::move(cont), alloc). Konstruuje comp przez skopiowanie compare. Następnie wywołuje std::make_heap(c.begin(), c.end(), comp).
    9) Konstruuje adapter wykorzystując zawartość other.c i używając alloc jako alokatora. W rzeczywistości wywołuje c(other.c, alloc). Konstruuje comp przez skopiowanie other.comp.
    10) Konstruuje opakowywany kontener przenosząc zawartość cont i używając alloc jako alokatora. W rzeczywistości wywołuje c(std::move(other.c), alloc). Konstruuje comp przez przeniesienie other.comp.
    11) Konstruuje c przez skopiowanie cont i konstruuje comp przez skopiowanie compare. Następnie wywołuje c.insert(c.end(), first, last);, i po tym wywołuje std::make_heap(c.begin(), c.end(), comp);.
    12) Konstruuje opakowywany kontener c przenosząc zawartość cont i konstruuje comp przenosząc zawartość compare. Następnie wywołuje c.insert(c.end(), first, last);, i po tym wywołuje std::make_heap(c.begin(), c.end(), comp);.

    Parametry

    alloc - alokator używany do wszystkich alokacji pamięci wykonywanych przez opakowywany kontener
    other - inny adapter, wykorzystywany jako źródło, z którego inicjalizowany jest opakowywany kontener
    cont - inny kontener, wykorzystywany jako źródło, którym inicjalizowany jest opakowywany kontener
    compare - obiekt funkcji porównującej, do zainicjalizowania opakowywanego funktora porównującego
    first, last - przedział, z którego zostają skopiowane elementy
    Wymagania względem typów
    -
    Alloc musi spełniać wymagania Alokator.
    -
    Container musi spełniać wymagania Container. Konstruktory (5-10) są definiowane, jeśli Container spełnia wymagania AllocatorAwareContainer
    -
    InputIt musi spełniać wymagania InputIterator.

    Złożoność

    1,3) O(N) porównań, gdzie N to cont.size().
    Dodatkowo, O(N) wywołań konstruktora value_type, gdzie N to cont.size().
    2) O(N) porównań, gdzie N to cont.size().
    4-6) Stała.
    7) O(N) porównań, gdzie N to cont.size().
    Dodatkowo, O(N) wywołań konstruktora value_type, gdzie N to cont.size().
    8) O(N) porównań, gdzie N to cont.size().
    9) Liniowa względem rozmiaru other.
    10) Stała.
    11) O(N) porównań, gdzie N to cont.size() + std::distance(first, last).
    Dodatkowo, O(N) wywołań konstruktora value_type, gdzie N to cont.size().
    12) O(N) porównań, gdzie N to cont.size() + std::distance(first, last).

    Przykład

    #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';
}

    Wynik: 

    1
1
5

    Przykład z własną funkcją porównującą

    #include <iostream>
#include <queue>
#include <vector>
#include <utility>

using my_pair_t = std::pair<size_t,bool>;

using my_container_t = std::vector<my_pair_t>;

int main()
{
    auto my_comp =
        [](const my_pair_t& e1, const my_pair_t& e2) 
        { return e1.first > e2.first; };
    std::priority_queue<my_pair_t,
                        my_container_t,
                        decltype(my_comp)> queue(my_comp);
    queue.push(std::make_pair(5, true));
    queue.push(std::make_pair(3, false));
    queue.push(std::make_pair(7, true));
    std::cout << std::boolalpha;
    while(!queue.empty()) 
    {
        const auto& p = queue.top();
        std::cout << p.first << " " << p.second << "\n";
        queue.pop();
    }
}

    Wynik: 

    3 false
5 true
7 true

    Zobacz także

    		 przypisuje wartości do adaptora kontenera
    (publiczna metoda) [edit]