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

Files changed (1) hide show

tmp/tmp2ag98za3/{from.md → to.md} +169 -88

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

@@ -1,8 +1,8 @@
-### `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;
 ```
@@ -13,334 +13,415 @@ const charT* data() const noexcept;
 *Complexity:* Constant time.
 *Requires:* The program shall not alter any of the values stored in the
 character array.
 ``` 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(const basic_string& str,
-               size_type pos = 0) const noexcept;
 ```
 *Effects:* Determines the lowest position `xpos`, if possible, such that
-both of the following conditions obtain:
-- `pos <= xpos` and `xpos + str.size() <= size()`;
-- `traits::eq(at(xpos+I), str.at(I))` for all elements `I` of the string
- controlled by `str`.
 *Returns:* `xpos` if the function can determine such a value for `xpos`.
 Otherwise, returns `npos`.
-*Remarks:* Uses `traits::eq()`.
 ``` cpp
 size_type find(const charT* s, size_type pos, size_type n) const;
 ```
-*Returns:* `find(basic_string(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(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(const basic_string& str,
-                size_type pos = npos) const noexcept;
 ```
 *Effects:* Determines the highest position `xpos`, if possible, such
-that both of the following conditions obtain:
-- `xpos <= pos` and `xpos + str.size() <= size()`;
-- `traits::eq(at(xpos+I), str.at(I))` for all elements `I` of the string
- controlled by `str`.
 *Returns:* `xpos` if the function can determine such a value for `xpos`.
 Otherwise, returns `npos`.
-*Remarks:* Uses `traits::eq()`.
 ``` cpp
 size_type rfind(const charT* s, size_type pos, size_type n) const;
 ```
-*Returns:* `rfind(basic_string(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(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(const basic_string& str,
-                size_type pos = 0) const noexcept;
 ```
 *Effects:* Determines the lowest position `xpos`, if possible, such that
-both of the following conditions obtain:
 - `pos <= xpos` and `xpos < size()`;
-- `traits::eq(at(xpos), str.at(I))` for some element `I` of the string
- controlled by `str`.
 *Returns:* `xpos` if the function can determine such a value for `xpos`.
 Otherwise, returns `npos`.
-*Remarks:* Uses `traits::eq()`.
 ``` cpp
-size_type
-  find_first_of(const charT* s, size_type pos, size_type n) const;
 ```
-*Returns:* `find_first_of(basic_string(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(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(const basic_string& str,
-               size_type pos = npos) const noexcept;
 ```
 *Effects:* Determines the highest position `xpos`, if possible, such
-that both of the following conditions obtain:
 - `xpos <= pos` and `xpos < size()`;
-- `traits::eq(at(xpos), str.at(I))` for some element `I` of the string
- controlled by `str`.
 *Returns:* `xpos` if the function can determine such a value for `xpos`.
 Otherwise, returns `npos`.
-*Remarks:* Uses `traits::eq()`.
 ``` cpp
 size_type find_last_of(const charT* s, size_type pos, size_type n) const;
 ```
-*Returns:* `find_last_of(basic_string(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(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(const basic_string& str,
                             size_type pos = 0) const noexcept;
 ```
 *Effects:* Determines the lowest position `xpos`, if possible, such that
-both of the following conditions obtain:
 - `pos <= xpos` and `xpos < size()`;
-- `traits::eq(at(xpos), str.at(I))` for no element `I` of the string
- controlled by `str`.
 *Returns:* `xpos` if the function can determine such a value for `xpos`.
 Otherwise, returns `npos`.
-*Remarks:* Uses `traits::eq()`.
 ``` cpp
-size_type
-  find_first_not_of(const charT* s, size_type pos, size_type n) const;
 ```
-*Returns:* `find_first_not_of(basic_string(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(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(const basic_string& str,
                            size_type pos = npos) const noexcept;
 ```
 *Effects:* Determines the highest position `xpos`, if possible, such
-that both of the following conditions obtain:
 - `xpos <= pos` and `xpos < size()`;
-- `traits::eq(at(xpos), str.at(I))` for no element `I` of the string
- controlled by `str`.
 *Returns:* `xpos` if the function can determine such a value for `xpos`.
 Otherwise, returns `npos`.
-*Remarks:* Uses `traits::eq()`.
 ``` cpp
-size_type find_last_not_of(const charT* s, size_type pos,
-                           size_type n) const;
 ```
-*Returns:* `find_last_not_of(basic_string(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(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;
 ```
-*Requires:* `pos <= size()`
 *Throws:* `out_of_range` if `pos > size()`.
 *Effects:* Determines the effective length `rlen` of the string to copy
 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(const basic_string& str) const noexcept;
 ```
-*Effects:* Determines the effective length *rlen* of the strings to
-compare as the smallest of `size()` and `str.size()`. The function then
 compares the two strings by calling
-`traits::compare(data(), str.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() <  str.size()` | `< 0`        |
-| `size() == str.size()` | `  0`        |
-| `size() >  str.size()` | `> 0`        |
 ``` cpp
-int compare(size_type pos1, size_type n1,
-            const basic_string& str) const;
 ```
-*Returns:* `basic_string(*this,pos1,n1).compare(str)`.
 ``` cpp
 int compare(size_type pos1, size_type n1,
             const basic_string& str,
             size_type pos2, size_type n2 = npos) const;
 ```
-*Returns:*
-`basic_string(*this, pos1, n1).compare(basic_string(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))`.

+#### `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;
 ```
 *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
 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))`.

Diff to HTML by rtfpessoa