From Jason Turner

[flat.multimap.cons]

C++20 → C++23 4.8 KB 109 lines
Current Draft | LaTeX Source
Archived: C++20 | C++23
Markdown: C++20 | C++23
Explore in Adventure Game

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmp6kdy1als/{from.md → to.md} +106 -0
tmp/tmp6kdy1als/{from.md → to.md} RENAMED
@@ -0,0 +1,106 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #### Constructors <a id="flat.multimap.cons">[[flat.multimap.cons]]</a>
2
+
3
+ ``` cpp
4
+ flat_multimap(key_container_type key_cont, mapped_container_type mapped_cont,
5
+ const key_compare& comp = key_compare());
6
+ ```
7
+
8
+ *Effects:* Initializes `c.keys` with `std::move(key_cont)`, `c.values`
9
+ with `std::move(mapped_cont)`, and `compare` with `comp`; sorts the
10
+ range \[`begin()`, `end()`) with respect to `value_comp()`.
11
+
12
+ *Complexity:* Linear in N if the container arguments are already sorted
13
+ with respect to `value_comp()` and otherwise N log N, where N is the
14
+ value of `key_cont.size()` before this call.
15
+
16
+ ``` cpp
17
+ template<class Allocator>
18
+ flat_multimap(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
19
+ const Allocator& a);
20
+ template<class Allocator>
21
+ flat_multimap(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
22
+ const key_compare& comp, const Allocator& a);
23
+ ```
24
+
25
+ *Constraints:* `uses_allocator_v<key_container_type, Allocator>` is
26
+ `true` and `uses_allocator_v<mapped_container_type, Allocator>` is
27
+ `true`.
28
+
29
+ *Effects:* Equivalent to `flat_multimap(key_cont, mapped_cont)` and
30
+ `flat_multimap(key_cont, mapped_cont, comp)`, respectively, except that
31
+ `c.keys` and `c.values` are constructed with uses-allocator
32
+ construction [[allocator.uses.construction]].
33
+
34
+ *Complexity:* Same as `flat_multimap(key_cont, mapped_cont)` and
35
+ `flat_multimap(key_cont, mapped_cont, comp)`, respectively.
36
+
37
+ ``` cpp
38
+ flat_multimap(sorted_equivalent_t, key_container_type key_cont, mapped_container_type mapped_cont,
39
+ const key_compare& comp = key_compare());
40
+ ```
41
+
42
+ *Effects:* Initializes `c.keys` with `std::move(key_cont)`, `c.values`
43
+ with `std::move(mapped_cont)`, and `compare` with `comp`.
44
+
45
+ *Complexity:* Constant.
46
+
47
+ ``` cpp
48
+ template<class Allocator>
49
+ flat_multimap(sorted_equivalent_t s, const key_container_type& key_cont,
50
+ const mapped_container_type& mapped_cont, const Allocator& a);
51
+ template<class Allocator>
52
+ flat_multimap(sorted_equivalent_t s, const key_container_type& key_cont,
53
+ const mapped_container_type& mapped_cont, const key_compare& comp,
54
+ const Allocator& a);
55
+ ```
56
+
57
+ *Constraints:* `uses_allocator_v<key_container_type, Allocator>` is
58
+ `true` and `uses_allocator_v<mapped_container_type, Allocator>` is
59
+ `true`.
60
+
61
+ *Effects:* Equivalent to `flat_multimap(s, key_cont, mapped_cont)` and
62
+ `flat_multimap(s, key_cont, mapped_cont, comp)`, respectively, except
63
+ that `c.keys` and `c.values` are constructed with uses-allocator
64
+ construction [[allocator.uses.construction]].
65
+
66
+ *Complexity:* Linear.
67
+
68
+ ``` cpp
69
+ template<class Allocator>
70
+ flat_multimap(const key_compare& comp, const Allocator& a);
71
+ template<class Allocator>
72
+ explicit flat_multimap(const Allocator& a);
73
+ template<class InputIterator, class Allocator>
74
+ flat_multimap(InputIterator first, InputIterator last, const key_compare& comp,
75
+ const Allocator& a);
76
+ template<class InputIterator, class Allocator>
77
+ flat_multimap(InputIterator first, InputIterator last, const Allocator& a);
78
+ template<container-compatible-range<value_type> R, class Allocator>
79
+ flat_multimap(from_range_t, R&& rg, const Allocator& a);
80
+ template<container-compatible-range<value_type> R, class Allocator>
81
+ flat_multimap(from_range_t, R&& rg, const key_compare& comp, const Allocator& a);
82
+ template<class InputIterator, class Allocator>
83
+ flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
84
+ const key_compare& comp, const Allocator& a);
85
+ template<class InputIterator, class Allocator>
86
+ flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
87
+ const Allocator& a);
88
+ template<class Allocator>
89
+ flat_multimap(initializer_list<value_type> il, const key_compare& comp, const Allocator& a);
90
+ template<class Allocator>
91
+ flat_multimap(initializer_list<value_type> il, const Allocator& a);
92
+ template<class Allocator>
93
+ flat_multimap(sorted_equivalent_t, initializer_list<value_type> il,
94
+ const key_compare& comp, const Allocator& a);
95
+ template<class Allocator>
96
+ flat_multimap(sorted_equivalent_t, initializer_list<value_type> il, const Allocator& a);
97
+ ```
98
+
99
+ *Constraints:* `uses_allocator_v<key_container_type, Allocator>` is
100
+ `true` and `uses_allocator_v<mapped_container_type, Allocator>` is
101
+ `true`.
102
+
103
+ *Effects:* Equivalent to the corresponding non-allocator constructors
104
+ except that `c.keys` and `c.values` are constructed with uses-allocator
105
+ construction [[allocator.uses.construction]].
106
+