[string.ops] - C++17 → C++20

Files changed (1) hide show

tmp/tmp94ybq_65/{from.md → to.md} +124 -298

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

@@ -1,328 +1,120 @@
-#### `basic_string` string operations <a id="string.ops">[[string.ops]]</a>
-##### `basic_string` accessors <a id="string.accessors">[[string.accessors]]</a>
 ``` cpp
-const charT* c_str() const noexcept;
-const charT* data() const noexcept;
 ```
-*Returns:* A pointer `p` such that `p + i == &operator[](i)` for each
-`i` in \[`0`, `size()`\].
 *Complexity:* Constant time.
-*Requires:* The program shall not alter any of the values stored in the
-character array.
 ``` cpp
-charT* data() noexcept;
 ```
-*Returns:* A pointer `p` such that `p + i == &operator[](i)` for each
-`i` in \[`0`, `size()`\].
 *Complexity:* Constant time.
-*Requires:* The program shall not alter the value stored at
-`p + size()`.
 ``` cpp
-operator basic_string_view<charT, traits>() const noexcept;
 ```
 *Effects:* Equivalent to:
 `return basic_string_view<charT, traits>(data(), size());`
 ``` cpp
-allocator_type get_allocator() const noexcept;
 ```
 *Returns:* A copy of the `Allocator` object used to construct the string
 or, if that allocator has been replaced, a copy of the most recent
 replacement.
-##### `basic_string::find` <a id="string.find">[[string.find]]</a>
-``` cpp
-size_type find(basic_string_view<charT, traits> sv, size_type pos = 0) const noexcept;
-```
-*Effects:* Determines the lowest position `xpos`, if possible, such that
-both of the following conditions hold:
-- `pos <= xpos` and `xpos + sv.size() <= size()`;
-- `traits::eq(at(xpos + I), sv.at(I))` for all elements `I` of the data
-  referenced by `sv`.
-*Returns:* `xpos` if the function can determine such a value for `xpos`.
-Otherwise, returns `npos`.
-``` cpp
-size_type find(const basic_string& str, size_type pos = 0) const noexcept;
-```
-*Effects:* Equivalent to:
-`return find(basic_string_view<charT, traits>(str), pos);`
-``` cpp
-size_type find(const charT* s, size_type pos, size_type n) const;
-```
-*Returns:* `find(basic_string_view<charT, traits>(s, n), pos)`.
-``` cpp
-size_type find(const charT* s, size_type pos = 0) const;
-```
-*Requires:* `s` points to an array of at least `traits::length(s) + 1`
-elements of `charT`.
-*Returns:* `find(basic_string_view<charT, traits>(s), pos)`.
-``` cpp
-size_type find(charT c, size_type pos = 0) const;
-```
-*Returns:* `find(basic_string(1, c), pos)`.
-##### `basic_string::rfind` <a id="string.rfind">[[string.rfind]]</a>
-``` cpp
-size_type rfind(basic_string_view<charT, traits> sv, size_type pos = npos) const noexcept;
-```
-*Effects:* Determines the highest position `xpos`, if possible, such
-that both of the following conditions hold:
-- `xpos <= pos` and `xpos + sv.size() <= size()`;
-- `traits::eq(at(xpos + I), sv.at(I))` for all elements `I` of the data
-  referenced by `sv`.
-*Returns:* `xpos` if the function can determine such a value for `xpos`.
-Otherwise, returns `npos`.
-``` cpp
-size_type rfind(const basic_string& str, size_type pos = npos) const noexcept;
-```
-*Effects:* Equivalent to:
-`return rfind(basic_string_view<charT, traits>(str), pos);`
-``` cpp
-size_type rfind(const charT* s, size_type pos, size_type n) const;
-```
-*Returns:* `rfind(basic_string_view<charT, traits>(s, n), pos)`.
   ``` cpp
-size_type rfind(const charT* s, size_type pos = npos) const;
   ```
-*Requires:* `s` points to an array of at least `traits::length(s) + 1`
-elements of `charT`.
-*Returns:* `rfind(basic_string_view<charT, traits>(s), pos)`.
   ``` cpp
-size_type rfind(charT c, size_type pos = npos) const;
   ```
-*Returns:* `rfind(basic_string(1, c), pos)`.
-##### `basic_string::find_first_of` <a id="string.find.first.of">[[string.find.first.of]]</a>
   ``` cpp
-size_type find_first_of(basic_string_view<charT, traits> sv, size_type pos = 0) const noexcept;
   ```
-*Effects:* Determines the lowest position `xpos`, if possible, such that
-both of the following conditions hold:
-- `pos <= xpos` and `xpos < size()`;
-- `traits::eq(at(xpos), sv.at(I))` for some element `I` of the data
-  referenced by `sv`.
-*Returns:* `xpos` if the function can determine such a value for `xpos`.
-Otherwise, returns `npos`.
   ``` cpp
-size_type find_first_of(const basic_string& str, size_type pos = 0) const noexcept;
   ```
-*Effects:* Equivalent to:
-`return find_first_of(basic_string_view<charT, traits>(str), pos);`
   ``` cpp
-size_type find_first_of(const charT* s, size_type pos, size_type n) const;
   ```
-*Returns:* `find_first_of(basic_string_view<charT, traits>(s, n), pos)`.
-``` cpp
-size_type find_first_of(const charT* s, size_type pos = 0) const;
-```
-*Requires:* `s` points to an array of at least `traits::length(s) + 1`
-elements of `charT`.
-*Returns:* `find_first_of(basic_string_view<charT, traits>(s), pos)`.
-``` cpp
-size_type find_first_of(charT c, size_type pos = 0) const;
-```
-*Returns:* `find_first_of(basic_string(1, c), pos)`.
-##### `basic_string::find_last_of` <a id="string.find.last.of">[[string.find.last.of]]</a>
-``` cpp
-size_type find_last_of(basic_string_view<charT, traits> sv, size_type pos = npos) const noexcept;
-```
-*Effects:* Determines the highest position `xpos`, if possible, such
-that both of the following conditions hold:
-- `xpos <= pos` and `xpos < size()`;
-- `traits::eq(at(xpos), sv.at(I))` for some element `I` of the data
-  referenced by `sv`.
-*Returns:* `xpos` if the function can determine such a value for `xpos`.
-Otherwise, returns `npos`.
 ``` cpp
-size_type find_last_of(const basic_string& str, size_type pos = npos) const noexcept;
 ```
-*Effects:* Equivalent to:
-`return find_last_of(basic_string_view<charT, traits>(str), pos);`
-``` cpp
-size_type find_last_of(const charT* s, size_type pos, size_type n) const;
-```
-*Returns:* `find_last_of(basic_string_view<charT, traits>(s, n), pos)`.
-``` cpp
-size_type find_last_of(const charT* s, size_type pos = npos) const;
-```
-*Requires:* `s` points to an array of at least `traits::length(s) + 1`
-elements of `charT`.
-*Returns:* `find_last_of(basic_string_view<charT, traits>(s), pos)`.
-``` cpp
-size_type find_last_of(charT c, size_type pos = npos) const;
-```
-*Returns:* `find_last_of(basic_string(1, c), pos)`.
-##### `basic_string::find_first_not_of` <a id="string.find.first.not.of">[[string.find.first.not.of]]</a>
-``` cpp
-size_type find_first_not_of(basic_string_view<charT, traits> sv,
-                            size_type pos = 0) const noexcept;
-```
-*Effects:* Determines the lowest position `xpos`, if possible, such that
-both of the following conditions hold:
-- `pos <= xpos` and `xpos < size()`;
-- `traits::eq(at(xpos), sv.at(I))` for no element `I` of the data
-  referenced by `sv`.
-*Returns:* `xpos` if the function can determine such a value for `xpos`.
-Otherwise, returns `npos`.
-``` cpp
-size_type find_first_not_of(const basic_string& str, size_type pos = 0) const noexcept;
-```
-*Effects:* Equivalent to:
-``` cpp
-return find_first_not_of(basic_string_view<charT, traits>(str), pos);
-```
-``` cpp
-size_type find_first_not_of(const charT* s, size_type pos, size_type n) const;
-```
-*Returns:*
-`find_first_not_of(basic_string_view<charT, traits>(s, n), pos)`.
-``` cpp
-size_type find_first_not_of(const charT* s, size_type pos = 0) const;
-```
-*Requires:* `s` points to an array of at least `traits::length(s) + 1`
-elements of `charT`.
-*Returns:*
-`find_first_not_of(basic_string_view<charT, traits>(s), pos)`.
-``` cpp
-size_type find_first_not_of(charT c, size_type pos = 0) const;
-```
-*Returns:* `find_first_not_of(basic_string(1, c), pos)`.
-##### `basic_string::find_last_not_of` <a id="string.find.last.not.of">[[string.find.last.not.of]]</a>
-``` cpp
-size_type find_last_not_of(basic_string_view<charT, traits> sv,
-                           size_type pos = npos) const noexcept;
-```
-*Effects:* Determines the highest position `xpos`, if possible, such
-that both of the following conditions hold:
-- `xpos <= pos` and `xpos < size()`;
-- `traits::eq(at(xpos), sv.at(I))` for no element `I` of the data
-  referenced by `sv`.
-*Returns:* `xpos` if the function can determine such a value for `xpos`.
-Otherwise, returns `npos`.
-``` cpp
-size_type find_last_not_of(const basic_string& str, size_type pos = npos) const noexcept;
-```
-*Effects:* Equivalent to:
-``` cpp
-return find_last_not_of(basic_string_view<charT, traits>(str), pos);
-```
-``` cpp
-size_type find_last_not_of(const charT* s, size_type pos, size_type n) const;
-```
-*Returns:*
-`find_last_not_of(basic_string_view<charT, traits>(s, n), pos)`.
-``` cpp
-size_type find_last_not_of(const charT* s, size_type pos = npos) const;
-```
-*Requires:* `s` points to an array of at least `traits::length(s) + 1`
-elements of `charT`.
-*Returns:* `find_last_not_of(basic_string_view<charT, traits>(s), pos)`.
 ``` cpp
-size_type find_last_not_of(charT c, size_type pos = npos) const;
 ```
-*Returns:* `find_last_not_of(basic_string(1, c), pos)`.
 ##### `basic_string::substr` <a id="string.substr">[[string.substr]]</a>
 ``` cpp
-basic_string substr(size_type pos = 0, size_type n = npos) const;
 ```
 *Throws:* `out_of_range` if `pos > size()`.
 *Effects:* Determines the effective length `rlen` of the string to copy
@@ -331,97 +123,131 @@ as the smaller of `n` and `size() - pos`.
 *Returns:* `basic_string(data()+pos, rlen)`.
 ##### `basic_string::compare` <a id="string.compare">[[string.compare]]</a>
 ``` cpp
-int compare(basic_string_view<charT, traits> sv) const noexcept;
 ```
-*Effects:* Determines the effective length `rlen` of the strings to
-compare as the smaller of `size()` and `sv.size()`. The function then
-compares the two strings by calling
-`traits::compare(data(), sv.data(), rlen)`.
-*Returns:* The nonzero result if the result of the comparison is
-nonzero. Otherwise, returns a value as indicated in
-Table  [[tab:strings.compare]].
-**Table: `compare()` results** <a id="tab:strings.compare">[tab:strings.compare]</a>
-| Condition             | Return Value |
-| --------------------- | ------------ |
-| `size() <  sv.size()` | `< 0`        |
-| `size() == sv.size()` | `  0`        |
-| `size() >  sv.size()` | `> 0`        |
 ``` cpp
-int compare(size_type pos1, size_type n1, basic_string_view<charT, traits> sv) const;
 ```
 *Effects:* Equivalent to:
 ``` cpp
-return basic_string_view<charT, traits>(data(), size()).substr(pos1, n1).compare(sv);
 ```
 ``` cpp
 template<class T>
-  int compare(size_type pos1, size_type n1, const T& t,
                         size_type pos2, size_type n2 = npos) const;
 ```
 *Effects:* Equivalent to:
 ``` cpp
-basic_string_view<charT, traits> sv = t;
-return basic_string_view<charT, traits>(
-    data(), size()).substr(pos1, n1).compare(sv.substr(pos2, n2));
 ```
-*Remarks:* This function shall not participate in overload resolution
-unless `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
-`true` and `is_convertible_v<const T&, const charT*>` is `false`.
 ``` cpp
-int compare(const basic_string& str) const noexcept;
 ```
 *Effects:* Equivalent to:
 `return compare(basic_string_view<charT, traits>(str));`
 ``` cpp
-int compare(size_type pos1, size_type n1, const basic_string& str) const;
 ```
 *Effects:* Equivalent to:
 `return compare(pos1, n1, basic_string_view<charT, traits>(str));`
 ``` cpp
-int compare(size_type pos1, size_type n1,
-            const basic_string& str,
                       size_type pos2, size_type n2 = npos) const;
 ```
 *Effects:* Equivalent to:
 ``` cpp
 return compare(pos1, n1, basic_string_view<charT, traits>(str), pos2, n2);
 ```
 ``` cpp
-int compare(const charT* s) const;
 ```
-*Returns:* `compare(basic_string(s))`.
 ``` cpp
-int compare(size_type pos, size_type n1, const charT* s) const;
 ```
-*Returns:* `basic_string(*this, pos, n1).compare(basic_string(s))`.
 ``` cpp
-int compare(size_type pos, size_type n1, const charT* s, size_type n2) const;
 ```
-*Returns:* `basic_string(*this, pos, n1).compare(basic_string(s, n2))`.

+#### String operations <a id="string.ops">[[string.ops]]</a>
+##### Accessors <a id="string.accessors">[[string.accessors]]</a>
 ``` cpp
+constexpr const charT* c_str() const noexcept;
+constexpr const charT* data() const noexcept;
 ```
+*Returns:* A pointer `p` such that `p + i == addressof(operator[](i))`
+for each `i` in \[`0`, `size()`\].
 *Complexity:* Constant time.
+*Remarks:* The program shall not modify any of the values stored in the
+character array; otherwise, the behavior is undefined.
 ``` cpp
+constexpr charT* data() noexcept;
 ```
+*Returns:* A pointer `p` such that `p + i == addressof(operator[](i))`
+for each `i` in \[`0`, `size()`\].
 *Complexity:* Constant time.
+*Remarks:* The program shall not modify the value stored at `p + size()`
+to any value other than `charT()`; otherwise, the behavior is undefined.
 ``` cpp
+constexpr operator basic_string_view<charT, traits>() const noexcept;
 ```
 *Effects:* Equivalent to:
 `return basic_string_view<charT, traits>(data(), size());`
 ``` cpp
+constexpr allocator_type get_allocator() const noexcept;
 ```
 *Returns:* A copy of the `Allocator` object used to construct the string
 or, if that allocator has been replaced, a copy of the most recent
 replacement.
+##### Searching <a id="string.find">[[string.find]]</a>
+Let *F* be one of `find`, `rfind`, `find_first_of`, `find_last_of`,
+`find_first_not_of`, and `find_last_not_of`.
+- Each member function of the form
   ``` cpp
+  constexpr size_type F(const basic_string& str, size_type pos) const noexcept;
   ```
+  has effects equivalent to:
+  `return F(basic_string_view<charT, traits>(str), pos);`
+- Each member function of the form
   ``` cpp
+  constexpr size_type F(const charT* s, size_type pos) const;
   ```
+  has effects equivalent to:
+  `return F(basic_string_view<charT, traits>(s), pos);`
+- Each member function of the form
   ``` cpp
+  constexpr size_type F(const charT* s, size_type pos, size_type n) const;
   ```
+  has effects equivalent to:
+  `return F(basic_string_view<charT, traits>(s, n), pos);`
+- Each member function of the form
   ``` cpp
+  constexpr size_type F(charT c, size_type pos) const noexcept;
   ```
+  has effects equivalent to:
   ``` cpp
+  return F(basic_string_view<charT, traits>(addressof(c), 1), pos);
   ```
 ``` cpp
+template<class T>
+  constexpr size_type find(const T& t, size_type pos = 0) const noexcept(see below);
+template<class T>
+  constexpr size_type rfind(const T& t, size_type pos = npos) const noexcept(see below);
+template<class T>
+  constexpr size_type find_first_of(const T& t, size_type pos = 0) const noexcept(see below);
+template<class T>
+  constexpr size_type find_last_of(const T& t, size_type pos = npos) const noexcept(see below);
+template<class T>
+  constexpr size_type find_first_not_of(const T& t, size_type pos = 0) const noexcept(see below);
+template<class T>
+  constexpr size_type find_last_not_of(const T& t, size_type pos = npos) const noexcept(see below);
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+ `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
+*Effects:* Let *G* be the name of the function. Equivalent to:
 ``` cpp
+basic_string_view<charT, traits> s = *this, sv = t;
+return s.G(sv, pos);
 ```
+*Remarks:* The expression inside `noexcept` is equivalent to
+`is_nothrow_convertible_v<const T&, basic_string_view<charT, traits>>`.
 ##### `basic_string::substr` <a id="string.substr">[[string.substr]]</a>
 ``` cpp
+constexpr basic_string substr(size_type pos = 0, size_type n = npos) const;
 ```
 *Throws:* `out_of_range` if `pos > size()`.
 *Effects:* Determines the effective length `rlen` of the string to copy
 *Returns:* `basic_string(data()+pos, rlen)`.
 ##### `basic_string::compare` <a id="string.compare">[[string.compare]]</a>
 ``` cpp
+template<class T>
+  constexpr int compare(const T& t) const noexcept(see below);
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+  `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
+*Effects:* Equivalent to:
+`return basic_string_view<charT, traits>(*this).compare(t);`
+*Remarks:* The expression inside `noexcept` is equivalent to
+`is_nothrow_convertible_v<const T&, basic_string_view<charT, traits>>`.
 ``` cpp
+template<class T>
+  constexpr int compare(size_type pos1, size_type n1, const T& t) const;
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+  `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
 *Effects:* Equivalent to:
 ``` cpp
+return basic_string_view<charT, traits>(*this).substr(pos1, n1).compare(t);
 ```
 ``` cpp
 template<class T>
+ constexpr int compare(size_type pos1, size_type n1, const T& t,
                         size_type pos2, size_type n2 = npos) const;
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+  `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
 *Effects:* Equivalent to:
 ``` cpp
+basic_string_view<charT, traits> s = *this, sv = t;
+return s.substr(pos1, n1).compare(sv.substr(pos2, n2));
 ```
 ``` cpp
+constexpr int compare(const basic_string& str) const noexcept;
 ```
 *Effects:* Equivalent to:
 `return compare(basic_string_view<charT, traits>(str));`
 ``` cpp
+constexpr int compare(size_type pos1, size_type n1, const basic_string& str) const;
 ```
 *Effects:* Equivalent to:
 `return compare(pos1, n1, basic_string_view<charT, traits>(str));`
 ``` cpp
+constexpr int compare(size_type pos1, size_type n1, const basic_string& str,
                       size_type pos2, size_type n2 = npos) const;
 ```
 *Effects:* Equivalent to:
 ``` cpp
 return compare(pos1, n1, basic_string_view<charT, traits>(str), pos2, n2);
 ```
 ``` cpp
+constexpr int compare(const charT* s) const;
 ```
+*Effects:* Equivalent to:
+`return compare(basic_string_view<charT, traits>(s));`
 ``` cpp
+constexpr int compare(size_type pos, size_type n1, const charT* s) const;
 ```
+*Effects:* Equivalent to:
+`return compare(pos, n1, basic_string_view<charT, traits>(s));`
 ``` cpp
+constexpr int compare(size_type pos, size_type n1, const charT* s, size_type n2) const;
 ```
+*Effects:* Equivalent to:
+`return compare(pos, n1, basic_string_view<charT, traits>(s, n2));`
+##### `basic_string::starts_with` <a id="string.starts.with">[[string.starts.with]]</a>
+``` cpp
+constexpr bool starts_with(basic_string_view<charT, traits> x) const noexcept;
+constexpr bool starts_with(charT x) const noexcept;
+constexpr bool starts_with(const charT* x) const;
+```
+*Effects:* Equivalent to:
+``` cpp
+return basic_string_view<charT, traits>(data(), size()).starts_with(x);
+```
+##### `basic_string::ends_with` <a id="string.ends.with">[[string.ends.with]]</a>
+``` cpp
+constexpr bool ends_with(basic_string_view<charT, traits> x) const noexcept;
+constexpr bool ends_with(charT x) const noexcept;
+constexpr bool ends_with(const charT* x) const;
+```
+*Effects:* Equivalent to:
+``` cpp
+return basic_string_view<charT, traits>(data(), size()).ends_with(x);
+```

Diff to HTML by rtfpessoa