From Jason Turner

[priqueue.cons.alloc]

C++23 → Trunk 5.1 KB 34 lines
Current Draft | LaTeX Source
Archived: C++23
Markdown: C++23 | Trunk
Explore in Adventure Game

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmpip0gi8a4/{from.md → to.md} +16 -15
tmp/tmpip0gi8a4/{from.md → to.md} RENAMED
@@ -2,108 +2,109 @@
2
 
3
  If `uses_allocator_v<container_type, Alloc>` is `false` the constructors
4
  in this subclause shall not participate in overload resolution.
5
 
6
  ``` cpp
7
- template<class Alloc> explicit priority_queue(const Alloc& a);
8
  ```
9
 
10
  *Effects:* Initializes `c` with `a` and value-initializes `comp`.
11
 
12
  ``` cpp
13
- template<class Alloc> priority_queue(const Compare& compare, const Alloc& a);
14
  ```
15
 
16
  *Effects:* Initializes `c` with `a` and initializes `comp` with
17
  `compare`.
18
 
19
  ``` cpp
20
  template<class Alloc>
21
- priority_queue(const Compare& compare, const Container& cont, const Alloc& a);
22
  ```
23
 
24
  *Effects:* Initializes `c` with `cont` as the first argument and `a` as
25
  the second argument, and initializes `comp` with `compare`; calls
26
  `make_heap(c.begin(), c.end(), comp)`.
27
 
28
  ``` cpp
29
  template<class Alloc>
30
- priority_queue(const Compare& compare, Container&& cont, const Alloc& a);
31
  ```
32
 
33
  *Effects:* Initializes `c` with `std::move(cont)` as the first argument
34
  and `a` as the second argument, and initializes `comp` with `compare`;
35
  calls `make_heap(c.begin(), c.end(), comp)`.
36
 
37
  ``` cpp
38
- template<class Alloc> priority_queue(const priority_queue& q, const Alloc& a);
39
  ```
40
 
41
  *Effects:* Initializes `c` with `q.c` as the first argument and `a` as
42
  the second argument, and initializes `comp` with `q.comp`.
43
 
44
  ``` cpp
45
- template<class Alloc> priority_queue(priority_queue&& q, const Alloc& a);
46
  ```
47
 
48
  *Effects:* Initializes `c` with `std::move(q.c)` as the first argument
49
  and `a` as the second argument, and initializes `comp` with
50
  `std::move(q.comp)`.
51
 
52
  ``` cpp
53
  template<class InputIterator, class Alloc>
54
- priority_queue(InputIterator first, InputIterator last, const Alloc& a);
55
  ```
56
 
57
  *Effects:* Initializes `c` with `first` as the first argument, `last` as
58
  the second argument, and `a` as the third argument, and
59
  value-initializes `comp`; calls `make_heap(c.begin(), c.end(), comp)`.
60
 
61
  ``` cpp
62
  template<class InputIterator, class Alloc>
63
- priority_queue(InputIterator first, InputIterator last, const Compare& compare, const Alloc& a);
 
64
  ```
65
 
66
  *Effects:* Initializes `c` with `first` as the first argument, `last` as
67
  the second argument, and `a` as the third argument, and initializes
68
  `comp` with `compare`; calls `make_heap(c.begin(), c.end(), comp)`.
69
 
70
  ``` cpp
71
  template<class InputIterator, class Alloc>
72
- priority_queue(InputIterator first, InputIterator last, const Compare& compare,
73
  const Container& cont, const Alloc& a);
74
  ```
75
 
76
  *Effects:* Initializes `c` with `cont` as the first argument and `a` as
77
  the second argument, and initializes `comp` with `compare`; calls
78
  `c.insert(c.end(), first, last)`; and finally calls
79
  `make_heap(c.begin(), c.end(), comp)`.
80
 
81
  ``` cpp
82
  template<class InputIterator, class Alloc>
83
- priority_queue(InputIterator first, InputIterator last, const Compare& compare, Container&& cont,
84
- const Alloc& a);
85
  ```
86
 
87
  *Effects:* Initializes `c` with `std::move(cont)` as the first argument
88
  and `a` as the second argument, and initializes `comp` with `compare`;
89
  calls `c.insert(c.end(), first, last)`; and finally calls
90
  `make_heap(c.begin(), c.end(), comp)`.
91
 
92
  ``` cpp
93
  template<container-compatible-range<T> R, class Alloc>
94
- priority_queue(from_range_t, R&& rg, const Compare& compare, const Alloc& a);
95
  ```
96
 
97
  *Effects:* Initializes `comp` with `compare` and `c` with
98
  `ranges::to<Container>(std::forward<R>(rg), a)`; calls
99
  `make_heap(c.begin(), c.end(), comp)`.
100
 
101
  ``` cpp
102
  template<container-compatible-range<T> R, class Alloc>
103
- priority_queue(from_range_t, R&& rg, const Alloc& a);
104
  ```
105
 
106
  *Effects:* Initializes `c` with
107
- `ranges::to<Container>(std::forward<R>(rg), a)`; calls
108
- `make_heap(c.begin(), c.end(), comp)`.
109
 
 
2
 
3
  If `uses_allocator_v<container_type, Alloc>` is `false` the constructors
4
  in this subclause shall not participate in overload resolution.
5
 
6
  ``` cpp
7
+ template<class Alloc> constexpr explicit priority_queue(const Alloc& a);
8
  ```
9
 
10
  *Effects:* Initializes `c` with `a` and value-initializes `comp`.
11
 
12
  ``` cpp
13
+ template<class Alloc> constexpr priority_queue(const Compare& compare, const Alloc& a);
14
  ```
15
 
16
  *Effects:* Initializes `c` with `a` and initializes `comp` with
17
  `compare`.
18
 
19
  ``` cpp
20
  template<class Alloc>
21
+ constexpr priority_queue(const Compare& compare, const Container& cont, const Alloc& a);
22
  ```
23
 
24
  *Effects:* Initializes `c` with `cont` as the first argument and `a` as
25
  the second argument, and initializes `comp` with `compare`; calls
26
  `make_heap(c.begin(), c.end(), comp)`.
27
 
28
  ``` cpp
29
  template<class Alloc>
30
+ constexpr priority_queue(const Compare& compare, Container&& cont, const Alloc& a);
31
  ```
32
 
33
  *Effects:* Initializes `c` with `std::move(cont)` as the first argument
34
  and `a` as the second argument, and initializes `comp` with `compare`;
35
  calls `make_heap(c.begin(), c.end(), comp)`.
36
 
37
  ``` cpp
38
+ template<class Alloc> constexpr priority_queue(const priority_queue& q, const Alloc& a);
39
  ```
40
 
41
  *Effects:* Initializes `c` with `q.c` as the first argument and `a` as
42
  the second argument, and initializes `comp` with `q.comp`.
43
 
44
  ``` cpp
45
+ template<class Alloc> constexpr priority_queue(priority_queue&& q, const Alloc& a);
46
  ```
47
 
48
  *Effects:* Initializes `c` with `std::move(q.c)` as the first argument
49
  and `a` as the second argument, and initializes `comp` with
50
  `std::move(q.comp)`.
51
 
52
  ``` cpp
53
  template<class InputIterator, class Alloc>
54
+ constexpr priority_queue(InputIterator first, InputIterator last, const Alloc& a);
55
  ```
56
 
57
  *Effects:* Initializes `c` with `first` as the first argument, `last` as
58
  the second argument, and `a` as the third argument, and
59
  value-initializes `comp`; calls `make_heap(c.begin(), c.end(), comp)`.
60
 
61
  ``` cpp
62
  template<class InputIterator, class Alloc>
63
+ constexpr priority_queue(InputIterator first, InputIterator last,
64
+ const Compare& compare, const Alloc& a);
65
  ```
66
 
67
  *Effects:* Initializes `c` with `first` as the first argument, `last` as
68
  the second argument, and `a` as the third argument, and initializes
69
  `comp` with `compare`; calls `make_heap(c.begin(), c.end(), comp)`.
70
 
71
  ``` cpp
72
  template<class InputIterator, class Alloc>
73
+ constexpr priority_queue(InputIterator first, InputIterator last, const Compare& compare,
74
  const Container& cont, const Alloc& a);
75
  ```
76
 
77
  *Effects:* Initializes `c` with `cont` as the first argument and `a` as
78
  the second argument, and initializes `comp` with `compare`; calls
79
  `c.insert(c.end(), first, last)`; and finally calls
80
  `make_heap(c.begin(), c.end(), comp)`.
81
 
82
  ``` cpp
83
  template<class InputIterator, class Alloc>
84
+ constexpr priority_queue(InputIterator first, InputIterator last, const Compare& compare,
85
+ Container&& cont, const Alloc& a);
86
  ```
87
 
88
  *Effects:* Initializes `c` with `std::move(cont)` as the first argument
89
  and `a` as the second argument, and initializes `comp` with `compare`;
90
  calls `c.insert(c.end(), first, last)`; and finally calls
91
  `make_heap(c.begin(), c.end(), comp)`.
92
 
93
  ``` cpp
94
  template<container-compatible-range<T> R, class Alloc>
95
+ constexpr priority_queue(from_range_t, R&& rg, const Compare& compare, const Alloc& a);
96
  ```
97
 
98
  *Effects:* Initializes `comp` with `compare` and `c` with
99
  `ranges::to<Container>(std::forward<R>(rg), a)`; calls
100
  `make_heap(c.begin(), c.end(), comp)`.
101
 
102
  ``` cpp
103
  template<container-compatible-range<T> R, class Alloc>
104
+ constexpr priority_queue(from_range_t, R&& rg, const Alloc& a);
105
  ```
106
 
107
  *Effects:* Initializes `c` with
108
+ `ranges::to<Container>(std::forward<R>(rg), a)` and value-initializes
109
+ `comp`; calls `make_heap(c.begin(), c.end(), comp)`.
110