From Jason Turner

[flat.multimap.cons]

C++23 → Trunk 5.4 KB 99 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/tmp76sq74g1/{from.md → to.md} +8 -88
tmp/tmp76sq74g1/{from.md → to.md} RENAMED
@@ -1,106 +1,26 @@
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
-
 
1
  #### Constructors <a id="flat.multimap.cons">[[flat.multimap.cons]]</a>
2
 
3
  ``` cpp
4
+ constexpr 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)`,
9
+ *`c`*`.values` with `std::move(mapped_cont)`, and *compare* with `comp`;
10
+ sorts the 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
+ constexpr flat_multimap(sorted_equivalent_t, key_container_type key_cont,
18
+ mapped_container_type mapped_cont,
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
19
  const key_compare& comp = key_compare());
20
  ```
21
 
22
+ *Effects:* Initializes *`c`*`.keys` with `std::move(key_cont)`,
23
+ *`c`*`.values` with `std::move(mapped_cont)`, and *compare* with `comp`.
24
 
25
  *Complexity:* Constant.
26