[string.view.template] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpi7b70oy6/{from.md → to.md} +63 -53

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

@@ -46,36 +46,43 @@ namespace std {
     // [string.view.capacity], capacity
     constexpr size_type size() const noexcept;
     constexpr size_type length() const noexcept;
     constexpr size_type max_size() const noexcept;
- [[nodiscard]] constexpr bool empty() const noexcept;
     // [string.view.access], element access
     constexpr const_reference operator[](size_type pos) const;
-    constexpr const_reference at(size_type pos) const;
     constexpr const_reference front() const;
     constexpr const_reference back() const;
     constexpr const_pointer data() const noexcept;
     // [string.view.modifiers], modifiers
     constexpr void remove_prefix(size_type n);
     constexpr void remove_suffix(size_type n);
     constexpr void swap(basic_string_view& s) noexcept;
     // [string.view.ops], string operations
-    constexpr size_type copy(charT* s, size_type n, size_type pos = 0) const;
-    constexpr basic_string_view substr(size_type pos = 0, size_type n = npos) const;
     constexpr int compare(basic_string_view s) const noexcept;
-    constexpr int compare(size_type pos1, size_type n1, basic_string_view s) const;
     constexpr int compare(size_type pos1, size_type n1, basic_string_view s,
-                          size_type pos2, size_type n2) const;
     constexpr int compare(const charT* s) const;
-    constexpr int compare(size_type pos1, size_type n1, const charT* s) const;
-    constexpr int compare(size_type pos1, size_type n1, const charT* s, size_type n2) const;
     constexpr bool starts_with(basic_string_view x) const noexcept;
     constexpr bool starts_with(charT x) const noexcept;
     constexpr bool starts_with(const charT* x) const;
     constexpr bool ends_with(basic_string_view x) const noexcept;
@@ -139,15 +146,14 @@ same type as `charT`. — *end note*]
 For a `basic_string_view str`, any operation that invalidates a pointer
 in the range
 ``` cpp
-{[}str.data(), {str.data() + str.size()}{)}
 ```
-invalidates pointers, iterators, and references returned from `str`’s
-member functions.
 The complexity of `basic_string_view` member functions is 𝑂(1) unless
 otherwise specified.
 `basic_string_view<charT, traits>` is a trivially copyable type
@@ -157,31 +163,31 @@ otherwise specified.
 ``` cpp
 constexpr basic_string_view() noexcept;
 ```
-*Ensures:* `size_ == 0` and `data_ == nullptr`.
 ``` cpp
 constexpr basic_string_view(const charT* str);
 ```
 *Preconditions:* \[`str`, `str + traits::length(str)`) is a valid range.
-*Effects:* Constructs a `basic_string_view`, initializing `data_` with
-`str` and initializing `size_` with `traits::length(str)`.
 *Complexity:* 𝑂(`traits::length(str)`).
 ``` cpp
 constexpr basic_string_view(const charT* str, size_type len);
 ```
 *Preconditions:* \[`str`, `str + len`) is a valid range.
-*Effects:* Constructs a `basic_string_view`, initializing `data_` with
-`str` and initializing `size_` with `len`.
 ``` cpp
 template<class It, class End>
   constexpr basic_string_view(It begin, End end);
 ```
@@ -197,12 +203,12 @@ template<class It, class End>
 - \[`begin`, `end`) is a valid range.
 - `It` models `contiguous_iterator`.
 - `End` models `sized_sentinel_for<It>`.
-*Effects:* Initializes `data_` with `to_address(begin)` and initializes
-`size_` with `end - begin`.
 *Throws:* When and what `end - begin` throws.
 ``` cpp
 template<class R>
@@ -218,11 +224,11 @@ Let `d` be an lvalue of type `remove_cvref_t<R>`.
 - `is_same_v<ranges::range_value_t<R>, charT>` is `true`,
 - `is_convertible_v<R, const charT*>` is `false`, and
 - `d.operator ::std::basic_string_view<charT, traits>()` is not a valid
   expression.
-*Effects:* Initializes `data_` with `ranges::data(r)` and `size_` with
 `ranges::size(r)`.
 *Throws:* Any exception thrown by `ranges::data(r)` and
 `ranges::size(r)`.
@@ -265,11 +271,11 @@ constexpr const_iterator begin() const noexcept;
 constexpr const_iterator cbegin() const noexcept;
 ```
 *Returns:* An iterator such that
-- if `!empty()`, `addressof(*begin()) == data_`,
 - otherwise, an unspecified value such that \[`begin()`, `end()`) is a
   valid range.
 ``` cpp
 constexpr const_iterator end() const noexcept;
@@ -297,74 +303,73 @@ constexpr const_reverse_iterator crend() const noexcept;
 ``` cpp
 constexpr size_type size() const noexcept;
 constexpr size_type length() const noexcept;
 ```
-*Returns:* `size_`.
 ``` cpp
 constexpr size_type max_size() const noexcept;
 ```
 *Returns:* The largest possible number of char-like objects that can be
 referred to by a `basic_string_view`.
 ``` cpp
-[[nodiscard]] constexpr bool empty() const noexcept;
 ```
-*Returns:* `size_ == 0`.
 #### Element access <a id="string.view.access">[[string.view.access]]</a>
 ``` cpp
 constexpr const_reference operator[](size_type pos) const;
 ```
-*Preconditions:* `pos < size()`.
-*Returns:* `data_[pos]`.
 *Throws:* Nothing.
-[*Note 1*: Unlike `basic_string::operator[]`,
-`basic_string_view::operator[](size())` has undefined behavior instead
-of returning `charT()`. — *end note*]
 ``` cpp
 constexpr const_reference at(size_type pos) const;
 ```
-*Returns:* `data_[pos]`.
 *Throws:* `out_of_range` if `pos >= size()`.
 ``` cpp
 constexpr const_reference front() const;
 ```
-*Preconditions:* `!empty()`.
-*Returns:* `data_[0]`.
 *Throws:* Nothing.
 ``` cpp
 constexpr const_reference back() const;
 ```
-*Preconditions:* `!empty()`.
-*Returns:* `data_[size() - 1]`.
 *Throws:* Nothing.
 ``` cpp
 constexpr const_pointer data() const noexcept;
 ```
-*Returns:* `data_`.
 [*Note 2*: Unlike `basic_string::data()` and *string-literal*s,
 `data()` can return a pointer to a buffer that is not null-terminated.
 Therefore it is typically a mistake to pass `data()` to a function that
 takes just a `const charT*` and expects a null-terminated
@@ -374,21 +379,21 @@ string. — *end note*]
 ``` cpp
 constexpr void remove_prefix(size_type n);
 ```
-*Preconditions:* `n <= size()`.
-*Effects:* Equivalent to: `data_ += n; size_ -= n;`
 ``` cpp
 constexpr void remove_suffix(size_type n);
 ```
-*Preconditions:* `n <= size()`.
-*Effects:* Equivalent to: `size_ -= n;`
 ``` cpp
 constexpr void swap(basic_string_view& s) noexcept;
 ```
@@ -412,10 +417,11 @@ Let `rlen` be the smaller of `n` and `size() - pos`.
 *Complexity:* 𝑂(`rlen`).
 ``` cpp
 constexpr basic_string_view substr(size_type pos = 0, size_type n = npos) const;
 ```
 Let `rlen` be the smaller of `n` and `size() - pos`.
 *Effects:* Determines `rlen`, the effective length of the string to
@@ -486,11 +492,13 @@ constexpr int compare(size_type pos1, size_type n1, const charT* s, size_type n2
 ``` cpp
 constexpr bool starts_with(basic_string_view x) const noexcept;
 ```
-*Effects:* Equivalent to: `return substr(0, x.size()) == x;`
 ``` cpp
 constexpr bool starts_with(charT x) const noexcept;
 ```
@@ -504,14 +512,16 @@ constexpr bool starts_with(const charT* x) const;
 ``` cpp
 constexpr bool ends_with(basic_string_view x) const noexcept;
 ```
 *Effects:* Equivalent to:
 ``` cpp
-return size() >= x.size() && compare(size() - x.size(), npos, x) == 0;
 ```
 ``` cpp
 constexpr bool ends_with(charT x) const noexcept;
 ```
@@ -568,12 +578,12 @@ constexpr size_type find(basic_string_view str, size_type pos = 0) const noexcep
 Let `xpos` be the lowest position, if possible, such that the following
 conditions hold:
 - `pos <= xpos`
 - `xpos + str.size() <= size()`
-- `traits::eq(at(xpos + I), str.at(I))` for all elements `I` of the
-  string referenced by `str`.
 *Effects:* Determines `xpos`.
 *Returns:* `xpos` if the function can determine such a value for `xpos`.
 Otherwise, returns `npos`.
@@ -585,12 +595,12 @@ constexpr size_type rfind(basic_string_view str, size_type pos = npos) const noe
 Let `xpos` be the highest position, if possible, such that the following
 conditions hold:
 - `xpos <= pos`
 - `xpos + str.size() <= size()`
-- `traits::eq(at(xpos + I), str.at(I))` for all elements `I` of the
-  string referenced by `str`.
 *Effects:* Determines `xpos`.
 *Returns:* `xpos` if the function can determine such a value for `xpos`.
 Otherwise, returns `npos`.
@@ -602,12 +612,12 @@ constexpr size_type find_first_of(basic_string_view str, size_type pos = 0) cons
 Let `xpos` be the lowest position, if possible, such that the following
 conditions hold:
 - `pos <= xpos`
 - `xpos < size()`
-- `traits::eq(at(xpos), str.at(I))` for some element `I` of the string
-  referenced by `str`.
 *Effects:* Determines `xpos`.
 *Returns:* `xpos` if the function can determine such a value for `xpos`.
 Otherwise, returns `npos`.
@@ -619,12 +629,12 @@ constexpr size_type find_last_of(basic_string_view str, size_type pos = npos) co
 Let `xpos` be the highest position, if possible, such that the following
 conditions hold:
 - `xpos <= pos`
 - `xpos < size()`
-- `traits::eq(at(xpos), str.at(I))` for some element `I` of the string
-  referenced by `str`.
 *Effects:* Determines `xpos`.
 *Returns:* `xpos` if the function can determine such a value for `xpos`.
 Otherwise, returns `npos`.
@@ -636,12 +646,12 @@ constexpr size_type find_first_not_of(basic_string_view str, size_type pos = 0)
 Let `xpos` be the lowest position, if possible, such that the following
 conditions hold:
 - `pos <= xpos`
 - `xpos < size()`
-- `traits::eq(at(xpos), str.at(I))` for no element `I` of the string
-  referenced by `str`.
 *Effects:* Determines `xpos`.
 *Returns:* `xpos` if the function can determine such a value for `xpos`.
 Otherwise, returns `npos`.
@@ -653,12 +663,12 @@ constexpr size_type find_last_not_of(basic_string_view str, size_type pos = npos
 Let `xpos` be the highest position, if possible, such that the following
 conditions hold:
 - `xpos <= pos`
 - `xpos < size()`
-- `traits::eq(at(xpos), str.at(I))` for no element `I` of the string
-  referenced by `str`.
 *Effects:* Determines `xpos`.
 *Returns:* `xpos` if the function can determine such a value for `xpos`.
 Otherwise, returns `npos`.

     // [string.view.capacity], capacity
     constexpr size_type size() const noexcept;
     constexpr size_type length() const noexcept;
     constexpr size_type max_size() const noexcept;
+    constexpr bool empty() const noexcept;
     // [string.view.access], element access
     constexpr const_reference operator[](size_type pos) const;
+    constexpr const_reference at(size_type pos) const;                  // freestanding-deleted
     constexpr const_reference front() const;
     constexpr const_reference back() const;
     constexpr const_pointer data() const noexcept;
     // [string.view.modifiers], modifiers
     constexpr void remove_prefix(size_type n);
     constexpr void remove_suffix(size_type n);
     constexpr void swap(basic_string_view& s) noexcept;
     // [string.view.ops], string operations
+    constexpr size_type copy(charT* s, size_type n,
+                             size_type pos = 0) const;                  // freestanding-deleted
+    constexpr basic_string_view substr(size_type pos = 0,
+                                       size_type n = npos) const;       // freestanding-deleted
+    constexpr basic_string_view subview(size_type pos = 0,
+                                        size_type n = npos) const;      // freestanding-deleted
     constexpr int compare(basic_string_view s) const noexcept;
+    constexpr int compare(size_type pos1, size_type n1,
+                          basic_string_view s) const;                   // freestanding-deleted
     constexpr int compare(size_type pos1, size_type n1, basic_string_view s,
+                          size_type pos2, size_type n2) const;          // freestanding-deleted
     constexpr int compare(const charT* s) const;
+    constexpr int compare(size_type pos1, size_type n1,
+ const charT* s) const;                        // freestanding-deleted
+    constexpr int compare(size_type pos1, size_type n1, const charT* s,
+                          size_type n2) const;                          // freestanding-deleted
     constexpr bool starts_with(basic_string_view x) const noexcept;
     constexpr bool starts_with(charT x) const noexcept;
     constexpr bool starts_with(const charT* x) const;
     constexpr bool ends_with(basic_string_view x) const noexcept;
 For a `basic_string_view str`, any operation that invalidates a pointer
 in the range
 ``` cpp
+{[}str.data(), str.data() + str.size(){)}
 ```
+invalidates pointers, iterators, and references to elements of `str`.
 The complexity of `basic_string_view` member functions is 𝑂(1) unless
 otherwise specified.
 `basic_string_view<charT, traits>` is a trivially copyable type
 ``` cpp
 constexpr basic_string_view() noexcept;
 ```
+*Ensures:* *`size_`*` == 0` and *`data_`*` == nullptr`.
 ``` cpp
 constexpr basic_string_view(const charT* str);
 ```
 *Preconditions:* \[`str`, `str + traits::length(str)`) is a valid range.
+*Effects:* Constructs a `basic_string_view`, initializing *data\_* with
+`str` and initializing *size\_* with `traits::length(str)`.
 *Complexity:* 𝑂(`traits::length(str)`).
 ``` cpp
 constexpr basic_string_view(const charT* str, size_type len);
 ```
 *Preconditions:* \[`str`, `str + len`) is a valid range.
+*Effects:* Constructs a `basic_string_view`, initializing *data\_* with
+`str` and initializing *size\_* with `len`.
 ``` cpp
 template<class It, class End>
   constexpr basic_string_view(It begin, End end);
 ```
 - \[`begin`, `end`) is a valid range.
 - `It` models `contiguous_iterator`.
 - `End` models `sized_sentinel_for<It>`.
+*Effects:* Initializes *data\_* with `to_address(begin)` and initializes
+*size\_* with `end - begin`.
 *Throws:* When and what `end - begin` throws.
 ``` cpp
 template<class R>
 - `is_same_v<ranges::range_value_t<R>, charT>` is `true`,
 - `is_convertible_v<R, const charT*>` is `false`, and
 - `d.operator ::std::basic_string_view<charT, traits>()` is not a valid
   expression.
+*Effects:* Initializes *data\_* with `ranges::data(r)` and *size\_* with
 `ranges::size(r)`.
 *Throws:* Any exception thrown by `ranges::data(r)` and
 `ranges::size(r)`.
 constexpr const_iterator cbegin() const noexcept;
 ```
 *Returns:* An iterator such that
+- if `!empty()`, `addressof(*begin()) == `*`data_`*,
 - otherwise, an unspecified value such that \[`begin()`, `end()`) is a
   valid range.
 ``` cpp
 constexpr const_iterator end() const noexcept;
 ``` cpp
 constexpr size_type size() const noexcept;
 constexpr size_type length() const noexcept;
 ```
+*Returns:* *size\_*.
 ``` cpp
 constexpr size_type max_size() const noexcept;
 ```
 *Returns:* The largest possible number of char-like objects that can be
 referred to by a `basic_string_view`.
 ``` cpp
+constexpr bool empty() const noexcept;
 ```
+*Returns:* *`size_`*` == 0`.
 #### Element access <a id="string.view.access">[[string.view.access]]</a>
 ``` cpp
 constexpr const_reference operator[](size_type pos) const;
 ```
+`pos < size()` is `true`.
+[*Note 1*: This precondition is stronger than the one on
+`basic_string::operator[]`. — *end note*]
+*Returns:* *`data_`*`[pos]`.
 *Throws:* Nothing.
 ``` cpp
 constexpr const_reference at(size_type pos) const;
 ```
+*Returns:* *`data_`*`[pos]`.
 *Throws:* `out_of_range` if `pos >= size()`.
 ``` cpp
 constexpr const_reference front() const;
 ```
+`empty()` is `false`.
+*Returns:* *`data_`*`[0]`.
 *Throws:* Nothing.
 ``` cpp
 constexpr const_reference back() const;
 ```
+`empty()` is `false`.
+*Returns:* *`data_`*`[size() - 1]`.
 *Throws:* Nothing.
 ``` cpp
 constexpr const_pointer data() const noexcept;
 ```
+*Returns:* *data\_*.
 [*Note 2*: Unlike `basic_string::data()` and *string-literal*s,
 `data()` can return a pointer to a buffer that is not null-terminated.
 Therefore it is typically a mistake to pass `data()` to a function that
 takes just a `const charT*` and expects a null-terminated
 ``` cpp
 constexpr void remove_prefix(size_type n);
 ```
+`n <= size()` is `true`.
+*Effects:* Equivalent to: *`data_`*` += n; `*`size_`*` -= n;`
 ``` cpp
 constexpr void remove_suffix(size_type n);
 ```
+`n <= size()` is `true`.
+*Effects:* Equivalent to: *`size_`*` -= n;`
 ``` cpp
 constexpr void swap(basic_string_view& s) noexcept;
 ```
 *Complexity:* 𝑂(`rlen`).
 ``` cpp
 constexpr basic_string_view substr(size_type pos = 0, size_type n = npos) const;
+constexpr basic_string_view subview(size_type pos = 0, size_type n = npos) const;
 ```
 Let `rlen` be the smaller of `n` and `size() - pos`.
 *Effects:* Determines `rlen`, the effective length of the string to
 ``` cpp
 constexpr bool starts_with(basic_string_view x) const noexcept;
 ```
+Let `rlen` be the smaller of `size()` and `x.size()`.
+*Effects:* Equivalent to: `return basic_string_view(data(), rlen) == x;`
 ``` cpp
 constexpr bool starts_with(charT x) const noexcept;
 ```
 ``` cpp
 constexpr bool ends_with(basic_string_view x) const noexcept;
 ```
+Let `rlen` be the smaller of `size()` and `x.size()`.
 *Effects:* Equivalent to:
 ``` cpp
+return basic_string_view(data() + (size() - rlen), rlen) == x;
 ```
 ``` cpp
 constexpr bool ends_with(charT x) const noexcept;
 ```
 Let `xpos` be the lowest position, if possible, such that the following
 conditions hold:
 - `pos <= xpos`
 - `xpos + str.size() <= size()`
+- `traits::eq(`*`data_`*`[xpos + I], str[I])` for all elements `I` of
+ the string referenced by `str`.
 *Effects:* Determines `xpos`.
 *Returns:* `xpos` if the function can determine such a value for `xpos`.
 Otherwise, returns `npos`.
 Let `xpos` be the highest position, if possible, such that the following
 conditions hold:
 - `xpos <= pos`
 - `xpos + str.size() <= size()`
+- `traits::eq(`*`data_`*`[xpos + I], str[I])` for all elements `I` of
+ the string referenced by `str`.
 *Effects:* Determines `xpos`.
 *Returns:* `xpos` if the function can determine such a value for `xpos`.
 Otherwise, returns `npos`.
 Let `xpos` be the lowest position, if possible, such that the following
 conditions hold:
 - `pos <= xpos`
 - `xpos < size()`
+- `traits::eq(`*`data_`*`[xpos], str[I])` for some element `I` of the
+ string referenced by `str`.
 *Effects:* Determines `xpos`.
 *Returns:* `xpos` if the function can determine such a value for `xpos`.
 Otherwise, returns `npos`.
 Let `xpos` be the highest position, if possible, such that the following
 conditions hold:
 - `xpos <= pos`
 - `xpos < size()`
+- `traits::eq(`*`data_`*`[xpos], str[I])` for some element `I` of the
+ string referenced by `str`.
 *Effects:* Determines `xpos`.
 *Returns:* `xpos` if the function can determine such a value for `xpos`.
 Otherwise, returns `npos`.
 Let `xpos` be the lowest position, if possible, such that the following
 conditions hold:
 - `pos <= xpos`
 - `xpos < size()`
+- `traits::eq(`*`data_`*`[xpos], str[I])` for no element `I` of the
+ string referenced by `str`.
 *Effects:* Determines `xpos`.
 *Returns:* `xpos` if the function can determine such a value for `xpos`.
 Otherwise, returns `npos`.
 Let `xpos` be the highest position, if possible, such that the following
 conditions hold:
 - `xpos <= pos`
 - `xpos < size()`
+- `traits::eq(`*`data_`*`[xpos], str[I])` for no element `I` of the
+ string referenced by `str`.
 *Effects:* Determines `xpos`.
 *Returns:* `xpos` if the function can determine such a value for `xpos`.
 Otherwise, returns `npos`.

Diff to HTML by rtfpessoa