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) (C++11부터)
explicit priority_queue ( const Compare & compare )
: priority_queue ( compare, Container ( ) ) { }
(2) (C++11부터)
(3)
explicit priority_queue ( const Compare & compare = Compare ( ) ,
const Container & cont = Container ( ) ) ;
(C++11 이전)
priority_queue ( const Compare & compare, const Container & cont ) ;
(C++11 이후)
priority_queue ( const Compare & compare, Container && cont ) ;
(4) (C++11부터)
priority_queue ( const priority_queue & other ) ;
(5)
priority_queue ( priority_queue && other ) ;
(6) (C++11부터)
template < class InputIt >

priority_queue ( InputIt first, InputIt last,

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

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

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

priority_queue ( InputIt first, InputIt last,

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

priority_queue ( InputIt first, InputIt last,

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

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

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

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

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

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

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

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

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

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

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

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

const Compare & compare = Compare ( ) ) ;
(20) (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) (C++23부터)
template < container-compatible-range < T > R, class Alloc >
priority_queue ( std:: from_range_t , R && rg, const Alloc & alloc ) ;
(22) (C++23부터)

다양한 데이터 소스로부터 컨테이너 어댑터의 새로운 기반 컨테이너를 생성합니다.

1) 기본 생성자. 비교자와 기반 컨테이너를 값 초기화합니다.
2) 비교 함수 객체 comp 를 compare 의 내용으로 복사 생성합니다. 기반 컨테이너 c 를 값 초기화합니다.
3) 기본 컨테이너 c 를 cont 의 내용으로 복사 생성합니다. 비교 함수자 comp 를 compare 의 내용으로 복사 생성합니다. std:: make_heap ( c. begin ( ) , c. end ( ) , comp ) 를 호출합니다. 이는 또한 기본 생성자입니다. (C++11 이전)
4) 기본 컨테이너 c 를 std :: move ( cont ) 로 이동 생성합니다. 비교 함수 객체 comp 를 compare 로 복사 생성합니다. std:: make_heap ( c. begin ( ) , c. end ( ) , comp ) 를 호출합니다.
5) 복사 생성자 . 기본 컨테이너는 other. c 로 복사 생성됩니다. 비교 함수자는 other. comp 로 복사 생성됩니다. (암시적으로 선언됨)
6) 이동 생성자 . 기본 컨테이너는 std :: move ( other. c ) 로 생성됩니다. 비교 함수자는 std :: move ( other. comp ) 로 생성됩니다. (암시적으로 선언됨)
7-9) Iterator-pair 생성자. 이 오버로드들은 InputIt 가 LegacyInputIterator 요구사항을 충족할 때만 오버로드 해결에 참여합니다.
7) c 를 c ( first, last ) 와 같이 생성하고, comp 를 compare 에서 생성합니다. 그런 다음 std:: make_heap ( c. begin ( ) , c. end ( ) , comp ) ; 를 호출합니다.
8) c 를 cont 에서 복사 생성하고, comp 를 compare 에서 복사 생성합니다. 그런 다음 c. insert ( c. end ( ) , first, last ) ; 를 호출하고, 이어서 std:: make_heap ( c. begin ( ) , c. end ( ) , comp ) ; 를 호출합니다.
9) c 를 std :: move ( cont ) 에서 이동 생성하고, comp 를 compare 에서 복사 생성합니다. 그런 다음 c. insert ( c. end ( ) , first, last ) ; 를 호출하고, 이어서 std:: make_heap ( c. begin ( ) , c. end ( ) , comp ) ; 를 호출합니다.
10-15) 할당자 확장 생성자들. 이 오버로드들은 다음 조건에서만 오버로드 해결에 참여합니다: std:: uses_allocator < container_type, Alloc > :: value 가 true 인 경우, 즉 기본 컨테이너가 할당자 인식 컨테이너인 경우입니다(표준 라이브러리 컨테이너들은 모두 해당됩니다).
10) 기본 컨테이너를 alloc 을 할당자로 사용하여 구성합니다. 효과적으로 c ( alloc ) 를 호출합니다. comp 는 값 초기화됩니다.
11) 기본 컨테이너를 alloc 을 할당자로 사용하여 구성합니다. 효과적으로 c ( alloc ) 를 호출합니다. comp 를 compare 에서 복사 생성합니다.
12) 기본 컨테이너를 cont 의 내용과 alloc 를 할당자로 사용하여 c ( cont, alloc ) 처럼 구성합니다. comp 를 compare 에서 복사 생성합니다. 그런 다음 std:: make_heap ( c. begin ( ) , c. end ( ) , comp ) 를 호출합니다.
13) 기본 컨테이너를 alloc 을 할당자로 사용하면서 cont 의 내용을 이동 의미론을 사용하여 구성합니다. 마치 c ( std :: move ( cont ) , alloc ) 와 같이 수행됩니다. comp 를 compare 에서 복사 생성합니다. 그런 다음 std:: make_heap ( c. begin ( ) , c. end ( ) , comp ) 를 호출합니다.
14) 기본 컨테이너를 other. c 의 내용과 alloc 를 할당자로 사용하여 구성합니다. 효과적으로 c ( other. c , alloc ) 를 호출합니다. comp 를 other. comp 에서 복사 생성합니다.
15) alloc 를 할당자로 사용하면서 이동 의미론을 통해 other 의 내용으로 기반 컨테이너를 구성합니다. 효과적으로 c ( std :: move ( other. c ) , alloc ) 를 호출합니다. comp 를 other. comp 에서 이동 생성합니다.
16-19) 할당자-확장 반복자-쌍 생성자들. (7-9) 와 동일하지만, alloc 이 기반 컨테이너를 구성하는 데 사용됩니다. 이러한 오버로드들은 다음 조건에서만 오버로드 해결에 참여합니다: std:: uses_allocator < container_type, Alloc > :: value 가 true 이고 InputIt 이 LegacyInputIterator 를 만족하는 경우.
20) comp 을 compare 로 초기화하고 c 를 ranges:: to < Container > ( std:: forward < R > ( rg ) ) 로 초기화합니다. 그런 다음 std:: make_heap ( c. begin ( ) , c. end ( ) , comp ) 를 호출합니다.
21) comp 을 compare 로, c 를 ranges:: to < Container > ( std:: forward < R > ( rg ) , alloc ) 로 초기화합니다. 그런 다음 std:: make_heap ( c. begin ( ) , c. end ( ) , comp ) 를 호출합니다.
22) c 를 ranges:: to < Container > ( std:: forward < R > ( rg ) , alloc ) 로 초기화합니다. 그런 다음 std:: make_heap ( c. begin ( ) , c. end ( ) , comp ) 를 호출합니다.

구현이 어떤 타입이 LegacyInputIterator 요구사항을 만족하는지 확인하는 방법은 지정되지 않았으나, 정수 타입들은 반드시 거부되어야 합니다.

목차

매개변수

alloc - 기본 컨테이너의 모든 메모리 할당에 사용할 할당자
other - 기본 컨테이너를 초기화하는 데 소스로 사용할 다른 컨테이너 어댑터
cont - 기본 컨테이너를 초기화하는 데 소스로 사용할 컨테이너
compare - 기본 비교 함수 객체를 초기화할 비교 함수 객체
first, last - 초기화할 요소들의 범위 를 정의하는 반복자 쌍
rg - 컨테이너 호환 범위 , 즉 요소들이 T 로 변환 가능한 input_range
타입 요구사항
-
Alloc 는 Allocator 요구사항을 충족해야 함
-
Compare 는 Compare 요구사항을 충족해야 함
-
Container 는 Container 요구사항을 충족해야 함. 할당자 확장 생성자는 Container 가 AllocatorAwareContainer 요구사항을 충족할 때만 정의됨
-
InputIt 는 LegacyInputIterator 요구사항을 충족해야 함

복잡도

1,2) 상수.
3,5,12) O(N) 비교 및 O(N) 회의 value_type 생성자 호출, 여기서 N 은 cont. size ( ) 입니다.
4) O(N) 비교, 여기서 N 은 cont. size ( ) 입니다.
6) 상수.
7,16,17) O(M) 비교, 여기서 M 은 std:: distance ( first, last ) 입니다.
8,18) O(N + M) 비교와 O(N) 번의 value_type 생성자 호출, 여기서 N 은 cont. size ( ) 이고 M 은 std:: distance ( first, last ) 입니다.
9) O(N + M) 비교를 수행하며, 여기서 N 은 cont. size ( ) 이고 M 은 std:: distance ( first, last ) 입니다.
10,11) 상수.
13) O(N) 비교를 수행하며, 여기서 N 은 cont. size ( ) 입니다.
14) 크기가 other 에 대해 선형적입니다.
15) Alloc 가 other 의 할당자와 동일하게 비교되는 경우 상수 시간. 그렇지 않은 경우 other 의 크기에 선형 시간.
19) O(N + M) 번의 비교와 가능한 O(N) 번의 value_type 생성자 호출( Alloc 이 other 의 할당자와 동일하지 않은 경우 존재함), 여기서 N 은 cont. size ( ) 이고 M 은 std:: distance ( first, last ) 입니다.
20) O(N) 비교와 O(N) 번의 value_type 생성자 호출이 필요합니다. 여기서 N 은 ranges:: distance ( rg ) 입니다.
21,22)
이 섹션은 불완전합니다

참고 사항

Feature-test 매크로 값 표준 기능
__cpp_lib_containers_ranges 202202L (C++23) Ranges-aware 생성 및 삽입; 오버로드 ( 20-22 )

예제

이 코드 실행 
#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';
    // 사용자 정의 비교자 데모:
    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 범위 인식 생성자
}

출력: 

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)

결함 보고서

다음 동작 변경 결함 보고서는 이전에 게시된 C++ 표준에 소급 적용되었습니다.

DR 적용 대상 게시된 동작 올바른 동작
P0935R0 C++11 기본 생성자와 생성자 (4) 가 explicit였음 implicit로 변경됨
LWG 3506 C++11 allocator-extended iterator-pair 생성자가 누락됨 추가됨
LWG 3522 C++11 iterator-pair 생성자에 대한 제약 조건이 누락됨 추가됨
LWG 3529 C++11 iterator 쌍으로부터의 생성이 insert 를 호출함 iterator들로부터 컨테이너를 생성함

참고 항목

컨테이너 어댑터에 값을 할당합니다
(public member function)