[unord.req] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpxtfe66g0/{from.md → to.md} +43 -33

tmp/tmpxtfe66g0/{from.md → to.md} RENAMED Viewed

@@ -89,17 +89,17 @@ In this subclause,
 - `a_tran` denotes a value of type `X` or `const X` when the
   *qualified-id*s `X::key_equal::is_transparent` and
   `X::hasher::is_transparent` are both valid and denote types
   [[temp.deduct]],
 - `i` and `j` denote input iterators that refer to `value_type`,
-- `[i, j)` denotes a valid range,
 - `rg` denotes a value of a type `R` that models
   `container-compatible-range<value_type>`,
 - `p` and `q2` denote valid constant iterators to `a`,
 - `q` and `q1` denote valid dereferenceable constant iterators to `a`,
 - `r` denotes a valid dereferenceable iterator to `a`,
-- `[q1, q2)` denotes a valid range in `a`,
 - `il` denotes a value of type `initializer_list<value_type>`,
 - `t` denotes a value of type `X::value_type`,
 - `k` denotes a value of type `key_type`,
 - `hf` denotes a value of type `hasher` or `const hasher`,
 - `eq` denotes a value of type `key_equal` or `const key_equal`,
@@ -122,19 +122,19 @@ In this subclause,
 - `z` denotes a value of type `float`, and
 - `nh` denotes an rvalue of type `X::node_type`.
 A type `X` meets the *unordered associative container* requirements if
 `X` meets all the requirements of an allocator-aware container
-[[container.requirements.general]] and the following types, statements,
-and expressions are well-formed and have the specified semantics, except
 that for `unordered_map` and `unordered_multimap`, the requirements
-placed on `value_type` in [[container.alloc.reqmts]] apply instead to
 `key_type` and `mapped_type`.
-[*Note 3*: For example, `key_type` and `mapped_type` are sometimes
-required to be *Cpp17CopyAssignable* even though the associated
-`value_type`, `pair<const key_type, mapped_type>`, is not
 *Cpp17CopyAssignable*. — *end note*]
 ``` cpp
 typename X::key_type
 ```
@@ -401,12 +401,12 @@ X(il, n, hf, eq)
 ``` cpp
 X(b)
 ```
 *Effects:* In addition to the container
-requirements [[container.requirements.general]], copies the hash
-function, predicate, and maximum load factor.
 *Complexity:* Average case linear in `b.size()`, worst case quadratic.
 ``` cpp
 a = b
@@ -492,21 +492,15 @@ from `args`.
 a.emplace_hint(p, args)
 ```
 *Result:* `iterator`
-*Preconditions:* `value_type` is *Cpp17EmplaceConstructible* into `X`
-from `args`.
-*Effects:* Equivalent to `a.emplace(std::forward<Args>(args)...)`.
-*Returns:* An iterator pointing to the element with the key equivalent
-to the newly inserted element. The `const_iterator` `p` is a hint
-pointing to where the search should start. Implementations are permitted
-to ignore the hint.
-*Complexity:* Average case 𝑂(1), worst case 𝑂(`a.size()`).
 ``` cpp
 a_uniq.insert(t)
 ```
@@ -567,11 +561,11 @@ a.insert(i, j)
 *Result:* `void`
 *Preconditions:* `value_type` is *Cpp17EmplaceConstructible* into `X`
 from `*i`. Neither `i` nor `j` are iterators into `a`.
-*Effects:* Equivalent to `a.insert(t)` for each element in `[i,j)`.
 *Complexity:* Average case 𝑂(N), where N is `distance(i, j)`, worst case
 𝑂(N(`a.size()` + 1)).
 ``` cpp
@@ -773,11 +767,11 @@ a.erase(r)
 a.erase(q1, q2)
 ```
 *Result:* `iterator`
-*Effects:* Erases all elements in the range `[q1, q2)`.
 *Returns:* The iterator immediately following the erased elements prior
 to the erasure.
 *Complexity:* Average case linear in `distance(q1, q2)`, worst case
@@ -905,21 +899,37 @@ b.bucket(k)
 *Preconditions:* `b.bucket_count() > 0`.
 *Returns:* The index of the bucket in which elements with keys
 equivalent to `k` would be found, if any such element existed. The
-return value is in the range `[0, b.bucket_count())`.
 *Complexity:* Constant.
 ``` cpp
 b.bucket_size(n)
 ```
 *Result:* `size_type`
-*Preconditions:* `n` shall be in the range `[0, b.bucket_count())`.
 *Returns:* The number of elements in the `n`ᵗʰ bucket.
 *Complexity:* 𝑂(`b.bucket_size(n)`)
@@ -927,11 +937,11 @@ b.bucket_size(n)
 b.begin(n)
 ```
 *Result:* `local_iterator`; `const_local_iterator` for constant `b`.
-*Preconditions:* `n` is in the range `[0, b.bucket_count())`.
 *Returns:* An iterator referring to the first element in the bucket. If
 the bucket is empty, then `b.begin(n) == b.end(n)`.
 *Complexity:* Constant.
@@ -940,11 +950,11 @@ the bucket is empty, then `b.begin(n) == b.end(n)`.
 b.end(n)
 ```
 *Result:* `local_iterator`; `const_local_iterator` for constant `b`.
-*Preconditions:* `n` is in the range `[0, b.bucket_count())`.
 *Returns:* An iterator which is the past-the-end value for the bucket.
 *Complexity:* Constant.
@@ -952,11 +962,11 @@ b.end(n)
 b.cbegin(n)
 ```
 *Result:* `const_local_iterator`
-*Preconditions:* `n` shall be in the range `[0, b.bucket_count())`.
 *Returns:* An iterator referring to the first element in the bucket. If
 the bucket is empty, then `b.cbegin(n) == b.cend(n)`.
 *Complexity:* Constant.
@@ -965,11 +975,11 @@ the bucket is empty, then `b.cbegin(n) == b.cend(n)`.
 b.cend(n)
 ```
 *Result:* `const_local_iterator`
-*Preconditions:* `n` is in the range `[0, b.bucket_count())`.
 *Returns:* An iterator which is the past-the-end value for the bucket.
 *Complexity:* Constant.
@@ -1074,15 +1084,15 @@ accessing the element through such pointers and references while the
 element is owned by a `node_type` is undefined behavior. References and
 pointers to an element obtained while it is owned by a `node_type` are
 invalidated if the element is successfully inserted.
 The member function templates `find`, `count`, `equal_range`,
-`contains`, `extract`, and `erase` shall not participate in overload
-resolution unless the *qualified-id*s `Pred::is_transparent` and
-`Hash::is_transparent` are both valid and denote types [[temp.deduct]].
-Additionally, the member function templates `extract` and `erase` shall
-not participate in overload resolution if
 `is_convertible_v<K&&, iterator> || is_convertible_v<K&&, const_iterator>`
 is `true`, where `K` is the type substituted as the first template
 argument.
 A deduction guide for an unordered associative container shall not

 - `a_tran` denotes a value of type `X` or `const X` when the
   *qualified-id*s `X::key_equal::is_transparent` and
   `X::hasher::is_transparent` are both valid and denote types
   [[temp.deduct]],
 - `i` and `j` denote input iterators that refer to `value_type`,
+- \[`i`, `j`) denotes a valid range,
 - `rg` denotes a value of a type `R` that models
   `container-compatible-range<value_type>`,
 - `p` and `q2` denote valid constant iterators to `a`,
 - `q` and `q1` denote valid dereferenceable constant iterators to `a`,
 - `r` denotes a valid dereferenceable iterator to `a`,
+- \[`q1`, `q2`) denotes a valid range in `a`,
 - `il` denotes a value of type `initializer_list<value_type>`,
 - `t` denotes a value of type `X::value_type`,
 - `k` denotes a value of type `key_type`,
 - `hf` denotes a value of type `hasher` or `const hasher`,
 - `eq` denotes a value of type `key_equal` or `const key_equal`,
 - `z` denotes a value of type `float`, and
 - `nh` denotes an rvalue of type `X::node_type`.
 A type `X` meets the *unordered associative container* requirements if
 `X` meets all the requirements of an allocator-aware container
+[[container.alloc.reqmts]] and the following types, statements, and
+expressions are well-formed and have the specified semantics, except
 that for `unordered_map` and `unordered_multimap`, the requirements
+placed on `value_type` in [[container.reqmts]] apply instead to
 `key_type` and `mapped_type`.
+[*Note 3*: For example, `key_type` and `mapped_type` sometimes need to
+be *Cpp17CopyAssignable* even though the associated `value_type`,
+`pair<const key_type, mapped_type>`, is not
 *Cpp17CopyAssignable*. — *end note*]
 ``` cpp
 typename X::key_type
 ```
 ``` cpp
 X(b)
 ```
 *Effects:* In addition to the container
+requirements [[container.reqmts]], copies the hash function, predicate,
+and maximum load factor.
 *Complexity:* Average case linear in `b.size()`, worst case quadratic.
 ``` cpp
 a = b
 a.emplace_hint(p, args)
 ```
 *Result:* `iterator`
+*Effects:* Equivalent to `a.emplace(std::forward<Args>(args)...)`,
+except that the `const_iterator` `p` is a hint pointing to where the
+search should start. Implementations are permitted to ignore the hint.
+*Returns:* The iterator returned by `emplace`.
 ``` cpp
 a_uniq.insert(t)
 ```
 *Result:* `void`
 *Preconditions:* `value_type` is *Cpp17EmplaceConstructible* into `X`
 from `*i`. Neither `i` nor `j` are iterators into `a`.
+*Effects:* Equivalent to `a.insert(t)` for each element in \[`i`, `j`).
 *Complexity:* Average case 𝑂(N), where N is `distance(i, j)`, worst case
 𝑂(N(`a.size()` + 1)).
 ``` cpp
 a.erase(q1, q2)
 ```
 *Result:* `iterator`
+*Effects:* Erases all elements in the range \[`q1`, `q2`).
 *Returns:* The iterator immediately following the erased elements prior
 to the erasure.
 *Complexity:* Average case linear in `distance(q1, q2)`, worst case
 *Preconditions:* `b.bucket_count() > 0`.
 *Returns:* The index of the bucket in which elements with keys
 equivalent to `k` would be found, if any such element existed. The
+return value is in the range \[`0`, `b.bucket_count()`).
+*Complexity:* Constant.
+``` cpp
+a_tran.bucket(ke)
+```
+*Result:* `size_type`
+*Preconditions:* `a_tran.bucket_count() > 0`.
+*Ensures:* The return value is in the range \[`0`,
+`a_tran.bucket_count()`).
+*Returns:* The index of the bucket in which elements with keys
+equivalent to `ke` would be found, if any such element existed.
 *Complexity:* Constant.
 ``` cpp
 b.bucket_size(n)
 ```
 *Result:* `size_type`
+*Preconditions:* `n` shall be in the range \[`0`, `b.bucket_count()`).
 *Returns:* The number of elements in the `n`ᵗʰ bucket.
 *Complexity:* 𝑂(`b.bucket_size(n)`)
 b.begin(n)
 ```
 *Result:* `local_iterator`; `const_local_iterator` for constant `b`.
+*Preconditions:* `n` is in the range \[`0`, `b.bucket_count()`).
 *Returns:* An iterator referring to the first element in the bucket. If
 the bucket is empty, then `b.begin(n) == b.end(n)`.
 *Complexity:* Constant.
 b.end(n)
 ```
 *Result:* `local_iterator`; `const_local_iterator` for constant `b`.
+*Preconditions:* `n` is in the range \[`0`, `b.bucket_count()`).
 *Returns:* An iterator which is the past-the-end value for the bucket.
 *Complexity:* Constant.
 b.cbegin(n)
 ```
 *Result:* `const_local_iterator`
+*Preconditions:* `n` shall be in the range \[`0`, `b.bucket_count()`).
 *Returns:* An iterator referring to the first element in the bucket. If
 the bucket is empty, then `b.cbegin(n) == b.cend(n)`.
 *Complexity:* Constant.
 b.cend(n)
 ```
 *Result:* `const_local_iterator`
+*Preconditions:* `n` is in the range \[`0`, `b.bucket_count()`).
 *Returns:* An iterator which is the past-the-end value for the bucket.
 *Complexity:* Constant.
 element is owned by a `node_type` is undefined behavior. References and
 pointers to an element obtained while it is owned by a `node_type` are
 invalidated if the element is successfully inserted.
 The member function templates `find`, `count`, `equal_range`,
+`contains`, `extract`, `erase`, and `bucket` shall not participate in
+overload resolution unless the *qualified-id*s `Pred::is_transparent`
+and `Hash::is_transparent` are both valid and denote types
+[[temp.deduct]]. Additionally, the member function templates `extract`
+and `erase` shall not participate in overload resolution if
 `is_convertible_v<K&&, iterator> || is_convertible_v<K&&, const_iterator>`
 is `true`, where `K` is the type substituted as the first template
 argument.
 A deduction guide for an unordered associative container shall not

Diff to HTML by rtfpessoa