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

Files changed (1) hide show

tmp/tmp2xdne_2c/{from.md → to.md} +296 -314

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

@@ -1,667 +1,649 @@
-#### `basic_string` modifiers <a id="string.modifiers">[[string.modifiers]]</a>
-##### `basic_string::operator+=` <a id="string.op+=">[[string.op+=]]</a>
 ``` cpp
-basic_string&
-  operator+=(const basic_string& str);
 ```
-*Effects:* Calls `append(str)`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& operator+=(basic_string_view<charT, traits> sv);
 ```
-*Effects:* Calls `append(sv)`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& operator+=(const charT* s);
 ```
-*Effects:* Calls `append(s)`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& operator+=(charT c);
 ```
-*Effects:* Calls `push_back(c)`;
-*Returns:* `*this`.
 ``` cpp
-basic_string& operator+=(initializer_list<charT> il);
 ```
-*Effects:* Calls `append(il)`.
-*Returns:* `*this`.
 ##### `basic_string::append` <a id="string.append">[[string.append]]</a>
 ``` cpp
-basic_string&
-  append(const basic_string& str);
 ```
-*Effects:* Calls `append(str.data(), str.size())`.
-*Returns:* `*this`.
 ``` cpp
-basic_string&
-  append(const basic_string& str, size_type pos, size_type n = npos);
 ```
-*Throws:* `out_of_range` if `pos > str.size()`.
-*Effects:* Determines the effective length `rlen` of the string to
-append as the smaller of `n` and `str``.size() - ``pos` and calls
-`append(str.data() + pos, rlen)`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& append(basic_string_view<charT, traits> sv);
 ```
-*Effects:* Equivalent to: `return append(sv.data(), sv.size());`
 ``` cpp
 template<class T>
-  basic_string& append(const T& t, size_type pos, size_type n = npos);
 ```
-*Throws:* `out_of_range` if `pos > sv.size()`.
-*Effects:* Creates a variable, `sv`, as if by
-`basic_string_view<charT, traits> sv = t`. Determines the effective
-length `rlen` of the string to append as the smaller of `n` and
-`sv.size() - pos` and calls `append(sv.data() + pos, rlen)`.
-*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`.
-*Returns:* `*this`.
 ``` cpp
-basic_string&
-  append(const charT* s, size_type n);
 ```
-*Requires:* `s` points to an array of at least `n` elements of `charT`.
-*Throws:* `length_error` if `size() + n > max_size()`.
-*Effects:* The function replaces the string controlled by `*this` with a
-string of length `size() + n` whose first `size()` elements are a copy
-of the original string controlled by `*this` and whose remaining
-elements are a copy of the initial `n` elements of `s`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& append(const charT* s);
 ```
-*Requires:* `s` points to an array of at least `traits::length(s) + 1`
-elements of `charT`.
-*Effects:* Calls `append(s, traits::length(s))`.
 *Returns:* `*this`.
 ``` cpp
-basic_string& append(size_type n, charT c);
 ```
-*Effects:* Equivalent to `append(basic_string(n, c))`.
 *Returns:* `*this`.
 ``` cpp
 template<class InputIterator>
-  basic_string& append(InputIterator first, InputIterator last);
 ```
-*Requires:* \[`first`, `last`) is a valid range.
-*Effects:* Equivalent to
-`append(basic_string(first, last, get_allocator()))`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& append(initializer_list<charT> il);
 ```
-*Effects:* Calls `append(il.begin(), il.size())`.
-*Returns:* `*this`.
 ``` cpp
-void push_back(charT c);
 ```
-*Effects:* Equivalent to `append(static_cast<size_type>(1), c)`.
 ##### `basic_string::assign` <a id="string.assign">[[string.assign]]</a>
 ``` cpp
-basic_string& assign(const basic_string& str);
 ```
-*Effects:* Equivalent to `*this = str`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& assign(basic_string&& str)
   noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
            allocator_traits<Allocator>::is_always_equal::value);
 ```
-*Effects:* Equivalent to `*this = std::move(str)`.
-*Returns:* `*this`.
 ``` cpp
-basic_string&
-  assign(const basic_string& str, size_type pos,
-         size_type n = npos);
 ```
-*Throws:* `out_of_range` if `pos > str.size()`.
-*Effects:* Determines the effective length `rlen` of the string to
-assign as the smaller of `n` and `str``.size() - ``pos` and calls
-`assign(str.data() + pos, rlen)`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& assign(basic_string_view<charT, traits> sv);
 ```
-*Effects:* Equivalent to: `return assign(sv.data(), sv.size());`
 ``` cpp
 template<class T>
-  basic_string& assign(const T& t, size_type pos, size_type n = npos);
 ```
-*Throws:* `out_of_range` if `pos > sv.size()`.
-*Effects:* Creates a variable, `sv`, as if by
-`basic_string_view<charT, traits> sv = t`. Determines the effective
-length `rlen` of the string to assign as the smaller of `n` and
-`sv.size() - pos` and calls `assign(sv.data() + pos, rlen)`.
-*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`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& assign(const charT* s, size_type n);
 ```
-*Requires:* `s` points to an array of at least `n` elements of `charT`.
-*Throws:* `length_error` if `n > max_size()`.
-*Effects:* Replaces the string controlled by `*this` with a string of
-length `n` whose elements are a copy of those pointed to by `s`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& assign(const charT* s);
 ```
-*Requires:* `s` points to an array of at least `traits::length(s) + 1`
-elements of `charT`.
-*Effects:* Calls `assign(s, traits::length(s))`.
 *Returns:* `*this`.
 ``` cpp
-basic_string& assign(initializer_list<charT> il);
 ```
-*Effects:* Calls `assign(il.begin(), il.size())`.
-`*this`.
 ``` cpp
-basic_string& assign(size_type n, charT c);
 ```
-*Effects:* Equivalent to `assign(basic_string(n, c))`.
-*Returns:* `*this`.
 ``` cpp
 template<class InputIterator>
-  basic_string& assign(InputIterator first, InputIterator last);
 ```
-*Effects:* Equivalent to
-`assign(basic_string(first, last, get_allocator()))`.
-*Returns:* `*this`.
 ##### `basic_string::insert` <a id="string.insert">[[string.insert]]</a>
 ``` cpp
-basic_string&
-  insert(size_type pos,
-         const basic_string& str);
 ```
 *Effects:* Equivalent to: `return insert(pos, str.data(), str.size());`
 ``` cpp
-basic_string&
-  insert(size_type pos1,
-         const basic_string& str,
                                size_type pos2, size_type n = npos);
 ```
-*Throws:* `out_of_range` if `pos1 > size()` or `pos2 > str.size()`.
-*Effects:* Determines the effective length `rlen` of the string to
-insert as the smaller of `n` and `str.size() - pos2` and calls
-`insert(pos1, str.data() + pos2, rlen)`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& insert(size_type pos, basic_string_view<charT, traits> sv);
 ```
-*Effects:* Equivalent to: `return insert(pos, sv.data(), sv.size());`
 ``` cpp
 template<class T>
-  basic_string& insert(size_type pos1, const T& t,
                                  size_type pos2, size_type n = npos);
 ```
-*Throws:* `out_of_range` if `pos1 > size()` or `pos2 > sv.size()`.
-*Effects:* Creates a variable, `sv`, as if by
-`basic_string_view<charT, traits> sv = t`. Determines the effective
-length `rlen` of the string to assign as the smaller of `n` and
-`sv.size() - pos2` and calls `insert(pos1, sv.data() + pos2, rlen)`.
-*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`.
-*Returns:* `*this`.
 ``` cpp
-basic_string&
-  insert(size_type pos, const charT* s, size_type n);
 ```
-*Requires:* `s` points to an array of at least `n` elements of `charT`.
-*Throws:* `out_of_range` if `pos > size()` or `length_error` if
-`size() + n > max_size()`.
-*Effects:* Replaces the string controlled by `*this` with a string of
-length `size() + n` whose first `pos` elements are a copy of the initial
-elements of the original string controlled by `*this` and whose next `n`
-elements are a copy of the elements in `s` and whose remaining elements
-are a copy of the remaining elements of the original string controlled
-by `*this`.
 *Returns:* `*this`.
 ``` cpp
-basic_string&
-  insert(size_type pos, const charT* s);
 ```
-*Requires:* `s` points to an array of at least `traits::length(s) + 1`
-elements of `charT`.
 *Effects:* Equivalent to: `return insert(pos, s, traits::length(s));`
 ``` cpp
-basic_string&
-  insert(size_type pos, size_type n, charT c);
 ```
-*Effects:* Equivalent to `insert(pos, basic_string(n, c))`.
-*Returns:* `*this`.
 ``` cpp
-iterator insert(const_iterator p, charT c);
 ```
-*Requires:* `p` is a valid iterator on `*this`.
-*Effects:* Inserts a copy of `c` before the character referred to by
-`p`.
-*Returns:* An iterator which refers to the copy of the inserted
-character.
 ``` cpp
-iterator insert(const_iterator p, size_type n, charT c);
 ```
-*Requires:* `p` is a valid iterator on `*this`.
-*Effects:* Inserts `n` copies of `c` before the character referred to by
-`p`.
-*Returns:* An iterator which refers to the copy of the first inserted
-character, or `p` if `n == 0`.
 ``` cpp
 template<class InputIterator>
-  iterator insert(const_iterator p, InputIterator first, InputIterator last);
 ```
-*Requires:* `p` is a valid iterator on `*this`. `[first, last)` is a
-valid range.
 *Effects:* Equivalent to
 `insert(p - begin(), basic_string(first, last, get_allocator()))`.
-*Returns:* An iterator which refers to the copy of the first inserted
-character, or `p` if `first == last`.
 ``` cpp
-iterator insert(const_iterator p, initializer_list<charT> il);
 ```
-*Effects:* As if by `insert(p, il.begin(), il.end())`.
-*Returns:* An iterator which refers to the copy of the first inserted
-character, or `p` if `i1` is empty.
 ##### `basic_string::erase` <a id="string.erase">[[string.erase]]</a>
 ``` cpp
-basic_string& erase(size_type pos = 0, size_type n = npos);
 ```
 *Throws:* `out_of_range` if `pos` `> size()`.
 *Effects:* Determines the effective length `xlen` of the string to be
-removed as the smaller of `n` and `size() - pos`.
-The function then replaces the string controlled by `*this` with a
-string of length `size() - xlen` whose first `pos` elements are a copy
-of the initial elements of the original string controlled by `*this`,
-and whose remaining elements are a copy of the elements of the original
-string controlled by `*this` beginning at position `pos + xlen`.
 *Returns:* `*this`.
 ``` cpp
-iterator erase(const_iterator p);
 ```
 *Throws:* Nothing.
 *Effects:* Removes the character referred to by `p`.
 *Returns:* An iterator which points to the element immediately following
 `p` prior to the element being erased. If no such element exists,
 `end()` is returned.
 ``` cpp
-iterator erase(const_iterator first, const_iterator last);
 ```
-*Requires:* `first` and `last` are valid iterators on `*this`, defining
-a range `[first, last)`.
 *Throws:* Nothing.
 *Effects:* Removes the characters in the range `[first, last)`.
 *Returns:* An iterator which points to the element pointed to by `last`
 prior to the other elements being erased. If no such element exists,
 `end()` is returned.
 ``` cpp
-void pop_back();
 ```
-*Requires:* `!empty()`.
 *Throws:* Nothing.
-*Effects:* Equivalent to `erase(size() - 1, 1)`.
 ##### `basic_string::replace` <a id="string.replace">[[string.replace]]</a>
 ``` cpp
-basic_string&
-  replace(size_type pos1, size_type n1,
-          const basic_string& str);
 ```
 *Effects:* Equivalent to:
 `return replace(pos1, n1, str.data(), str.size());`
 ``` cpp
-basic_string&
-  replace(size_type pos1, size_type n1,
-          const basic_string& str,
                                 size_type pos2, size_type n2 = npos);
 ```
-*Throws:* `out_of_range` if `pos1 > size()` or `pos2 > str.size()`.
-*Effects:* Determines the effective length `rlen` of the string to be
-inserted as the smaller of `n2` and `str.size() - pos2` and calls
-`replace(pos1, n1, str.data() + pos2, rlen)`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& replace(size_type pos1, size_type n1,
-                      basic_string_view<charT, traits> sv);
 ```
 *Effects:* Equivalent to:
-`return replace(pos1, n1, sv.data(), sv.size());`
 ``` cpp
 template<class T>
-  basic_string& replace(size_type pos1, size_type n1, const T& t,
                                   size_type pos2, size_type n2 = npos);
 ```
-*Throws:* `out_of_range` if `pos1 > size()` or `pos2 > sv.size()`.
-*Effects:* Creates a variable, `sv`, as if by
-`basic_string_view<charT, traits> sv = t`. Determines the effective
-length `rlen` of the string to be inserted as the smaller of `n2` and
-`sv.size() - pos2` and calls
-`replace(pos1, n1, sv.data() + pos2, rlen)`.
-*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`.
-*Returns:* `*this`.
 ``` cpp
-basic_string&
-  replace(size_type pos1, size_type n1, const charT* s, size_type n2);
 ```
-*Requires:* `s` points to an array of at least `n2` elements of `charT`.
-*Throws:* `out_of_range` if `pos1 > size()` or `length_error` if the
-length of the resulting string would exceed `max_size()` (see below).
 *Effects:* Determines the effective length `xlen` of the string to be
 removed as the smaller of `n1` and `size() - pos1`. If
 `size() - xlen >= max_size() - n2` throws `length_error`. Otherwise, the
-function replaces the string controlled by \*`this` with a string of
-length `size() - xlen + n2` whose first `pos1` elements are a copy of
-the initial elements of the original string controlled by `*this`, whose
-next `n2` elements are a copy of the initial `n2` elements of `s`, and
-whose remaining elements are a copy of the elements of the original
-string controlled by `*this` beginning at position `pos + xlen`.
 *Returns:* `*this`.
 ``` cpp
-basic_string&
-  replace(size_type pos, size_type n, const charT* s);
 ```
-*Requires:* `s` points to an array of at least `traits::length(s) + 1`
-elements of `charT`.
 *Effects:* Equivalent to:
 `return replace(pos, n, s, traits::length(s));`
 ``` cpp
-basic_string&
-  replace(size_type pos1, size_type n1,
-          size_type n2, charT c);
 ```
-*Effects:* Equivalent to `replace(pos1, n1, basic_string(n2, c))`.
 *Returns:* `*this`.
 ``` cpp
-basic_string& replace(const_iterator i1, const_iterator i2, const basic_string& str);
 ```
-*Requires:* \[`begin()`, `i1`) and \[`i1`, `i2`) are valid ranges.
-*Effects:* Calls `replace(i1 - begin(), i2 - i1, str)`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& replace(const_iterator i1, const_iterator i2,
-                      basic_string_view<charT, traits> sv);
 ```
-*Requires:* \[`begin()`, `i1`) and \[`i1`, `i2`) are valid ranges.
-*Effects:* Calls `replace(i1 - begin(), i2 - i1, sv)`.
-*Returns:* `*this`.
 ``` cpp
-basic_string&
- replace(const_iterator i1, const_iterator i2, const charT* s, size_type n);
 ```
-*Requires:* \[`begin()`, `i1`) and \[`i1`, `i2`) are valid ranges and
-`s` points to an array of at least `n` elements of `charT`.
-*Effects:* Calls `replace(i1 - begin(), i2 - i1, s, n)`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& replace(const_iterator i1, const_iterator i2, const charT* s);
 ```
-*Requires:* \[`begin()`, `i1`) and \[`i1`, `i2`) are valid ranges and
-`s` points to an array of at least `traits::length(s) + 1` elements of
-`charT`.
-*Effects:* Calls `replace(i1 - begin(), i2 - i1, s, traits::length(s))`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& replace(const_iterator i1, const_iterator i2, size_type n,
-                      charT c);
 ```
-*Requires:* \[`begin()`, `i1`) and \[`i1`, `i2`) are valid ranges.
-*Effects:* Calls `replace(i1 - begin(), i2 - i1, basic_string(n, c))`.
-*Returns:* `*this`.
 ``` cpp
 template<class InputIterator>
-  basic_string& replace(const_iterator i1, const_iterator i2,
                                   InputIterator j1, InputIterator j2);
 ```
-*Requires:* \[`begin()`, `i1`), \[`i1`, `i2`) and \[`j1`, `j2`) are
-valid ranges.
-*Effects:* Calls
-`replace(i1 - begin(), i2 - i1, basic_string(j1, j2, get_allocator()))`.
-*Returns:* `*this`.
 ``` cpp
-basic_string& replace(const_iterator i1, const_iterator i2,
-                      initializer_list<charT> il);
 ```
-*Requires:* \[`begin()`, `i1`) and \[`i1`, `i2`) are valid ranges.
-*Effects:* Calls
-`replace(i1 - begin(), i2 - i1, il.begin(), il.size())`.
-*Returns:* `*this`.
 ##### `basic_string::copy` <a id="string.copy">[[string.copy]]</a>
 ``` cpp
-size_type copy(charT* s, size_type n, size_type pos = 0) const;
 ```
-Let `rlen` be the smaller of `n` and `size() - pos`.
-*Throws:* `out_of_range` if `pos > size()`.
-*Requires:* \[`s`, `s + rlen`) is a valid range.
-*Effects:* Equivalent to: `traits::copy(s, data() + pos, rlen)`.
 [*Note 1*: This does not terminate `s` with a null
 object. — *end note*]
-*Returns:* `rlen`.
 ##### `basic_string::swap` <a id="string.swap">[[string.swap]]</a>
 ``` cpp
-void swap(basic_string& s)
   noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
            allocator_traits<Allocator>::is_always_equal::value);
 ```
-*Postconditions:* `*this` contains the same sequence of characters that
-was in `s`, `s` contains the same sequence of characters that was in
-`*this`.
 *Throws:* Nothing.
 *Complexity:* Constant time.

+#### Modifiers <a id="string.modifiers">[[string.modifiers]]</a>
+##### `basic_string::operator+=` <a id="string.op.append">[[string.op.append]]</a>
 ``` cpp
+constexpr basic_string& operator+=(const basic_string& str);
 ```
+*Effects:* Equivalent to: `return append(str);`
 ``` cpp
+template<class T>
+  constexpr basic_string& operator+=(const T& t);
 ```
+*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> sv = t;
+return append(sv);
 ```
+``` cpp
+constexpr basic_string& operator+=(const charT* s);
+```
+*Effects:* Equivalent to: `return append(s);`
 ``` cpp
+constexpr basic_string& operator+=(charT c);
 ```
+*Effects:* Equivalent to: `return append(size_type{1}, c);`
 ``` cpp
+constexpr basic_string& operator+=(initializer_list<charT> il);
 ```
+*Effects:* Equivalent to: `return append(il);`
 ##### `basic_string::append` <a id="string.append">[[string.append]]</a>
 ``` cpp
+constexpr basic_string& append(const basic_string& str);
 ```
+*Effects:* Equivalent to: `return append(str.data(), str.size());`
 ``` cpp
+constexpr basic_string& append(const basic_string& str, size_type pos, size_type n = npos);
 ```
+*Effects:* Equivalent to:
 ``` cpp
+return append(basic_string_view<charT, traits>(str).substr(pos, n));
 ```
 ``` cpp
 template<class T>
+ constexpr basic_string& append(const T& t);
 ```
+*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> sv = t;
+return append(sv.data(), sv.size());
+```
 ``` cpp
+template<class T>
+ constexpr basic_string& append(const T& t, size_type pos, size_type n = npos);
 ```
+*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> sv = t;
+return append(sv.substr(pos, n));
+```
 ``` cpp
+constexpr basic_string& append(const charT* s, size_type n);
 ```
+*Preconditions:* \[`s`, `s + n`) is a valid range.
+*Effects:* Appends a copy of the range \[`s`, `s + n`) to the string.
 *Returns:* `*this`.
 ``` cpp
+constexpr basic_string& append(const charT* s);
+```
+*Effects:* Equivalent to: `return append(s, traits::length(s));`
+``` cpp
+constexpr basic_string& append(size_type n, charT c);
 ```
+*Effects:* Appends `n` copies of `c` to the string.
 *Returns:* `*this`.
 ``` cpp
 template<class InputIterator>
+ constexpr basic_string& append(InputIterator first, InputIterator last);
 ```
+*Constraints:* `InputIterator` is a type that qualifies as an input
+iterator [[container.requirements.general]].
+*Effects:* Equivalent to:
+`return append(basic_string(first, last, get_allocator()));`
 ``` cpp
+constexpr basic_string& append(initializer_list<charT> il);
 ```
+*Effects:* Equivalent to: `return append(il.begin(), il.size());`
 ``` cpp
+constexpr void push_back(charT c);
 ```
+*Effects:* Equivalent to `append(size_type{1}, c)`.
 ##### `basic_string::assign` <a id="string.assign">[[string.assign]]</a>
 ``` cpp
+constexpr basic_string& assign(const basic_string& str);
 ```
+*Effects:* Equivalent to: `return *this = str;`
 ``` cpp
+constexpr basic_string& assign(basic_string&& str)
   noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
            allocator_traits<Allocator>::is_always_equal::value);
 ```
+*Effects:* Equivalent to: `return *this = std::move(str);`
 ``` cpp
+constexpr basic_string& assign(const basic_string& str, size_type pos, size_type n = npos);
 ```
+*Effects:* Equivalent to:
 ``` cpp
+return assign(basic_string_view<charT, traits>(str).substr(pos, n));
 ```
 ``` cpp
 template<class T>
+ constexpr basic_string& assign(const T& t);
 ```
+*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> sv = t;
+return assign(sv.data(), sv.size());
+```
 ``` cpp
+template<class T>
+  constexpr basic_string& assign(const T& t, size_type pos, size_type n = npos);
 ```
+*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> sv = t;
+return assign(sv.substr(pos, n));
+```
 ``` cpp
+constexpr basic_string& assign(const charT* s, size_type n);
 ```
+*Preconditions:* \[`s`, `s + n`) is a valid range.
+*Effects:* Replaces the string controlled by `*this` with a copy of the
+range \[`s`, `s + n`).
 *Returns:* `*this`.
 ``` cpp
+constexpr basic_string& assign(const charT* s);
 ```
+*Effects:* Equivalent to: `return assign(s, traits::length(s));`
+``` cpp
+constexpr basic_string& assign(initializer_list<charT> il);
+```
+*Effects:* Equivalent to: `return assign(il.begin(), il.size());`
 ``` cpp
+constexpr basic_string& assign(size_type n, charT c);
 ```
+*Effects:* Equivalent to:
+``` cpp
+clear();
+resize(n, c);
+return *this;
+```
 ``` cpp
 template<class InputIterator>
+ constexpr basic_string& assign(InputIterator first, InputIterator last);
 ```
+*Constraints:* `InputIterator` is a type that qualifies as an input
+iterator [[container.requirements.general]].
+*Effects:* Equivalent to:
+`return assign(basic_string(first, last, get_allocator()));`
 ##### `basic_string::insert` <a id="string.insert">[[string.insert]]</a>
 ``` cpp
+constexpr basic_string& insert(size_type pos, const basic_string& str);
 ```
 *Effects:* Equivalent to: `return insert(pos, str.data(), str.size());`
 ``` cpp
+constexpr basic_string& insert(size_type pos1, const basic_string& str,
                                size_type pos2, size_type n = npos);
 ```
+*Effects:* Equivalent to:
+``` cpp
+return insert(pos1, basic_string_view<charT, traits>(str), pos2, n);
+```
 ``` cpp
+template<class T>
+  constexpr basic_string& insert(size_type pos, const T& t);
 ```
+*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> sv = t;
+return insert(pos, sv.data(), sv.size());
+```
 ``` cpp
 template<class T>
+ constexpr basic_string& insert(size_type pos1, const T& t,
                                  size_type pos2, size_type n = npos);
 ```
+*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> sv = t;
+return insert(pos1, sv.substr(pos2, n));
+```
 ``` cpp
+constexpr basic_string& insert(size_type pos, const charT* s, size_type n);
 ```
+*Preconditions:* \[`s`, `s + n`) is a valid range.
+*Throws:*
+- `out_of_range` if `pos > size()`,
+- `length_error` if `n > max_size() - size()`, or
+- any exceptions thrown by `allocator_traits<Allocator>::allocate`.
+*Effects:* Inserts a copy of the range \[`s`, `s + n`) immediately
+before the character at position `pos` if `pos < size()`, or otherwise
+at the end of the string.
 *Returns:* `*this`.
 ``` cpp
+constexpr basic_string& insert(size_type pos, const charT* s);
 ```
 *Effects:* Equivalent to: `return insert(pos, s, traits::length(s));`
 ``` cpp
+constexpr basic_string& insert(size_type pos, size_type n, charT c);
 ```
+*Effects:* Inserts `n` copies of `c` before the character at position
+`pos` if `pos < size()`, or otherwise at the end of the string.
+*Returns:* `*this`
+*Throws:*
+- `out_of_range` if `pos > size()`,
+- `length_error` if `n > max_size() - size()`, or
+- any exceptions thrown by `allocator_traits<Allocator>::allocate`.
 ``` cpp
+constexpr iterator insert(const_iterator p, charT c);
 ```
+*Preconditions:* `p` is a valid iterator on `*this`.
+*Effects:* Inserts a copy of `c` at the position `p`.
+*Returns:* An iterator which refers to the inserted character.
 ``` cpp
+constexpr iterator insert(const_iterator p, size_type n, charT c);
 ```
+*Preconditions:* `p` is a valid iterator on `*this`.
+*Effects:* Inserts `n` copies of `c` at the position `p`.
+*Returns:* An iterator which refers to the first inserted character, or
+`p` if `n == 0`.
 ``` cpp
 template<class InputIterator>
+ constexpr iterator insert(const_iterator p, InputIterator first, InputIterator last);
 ```
+*Constraints:* `InputIterator` is a type that qualifies as an input
+iterator [[container.requirements.general]].
+*Preconditions:* `p` is a valid iterator on `*this`.
 *Effects:* Equivalent to
 `insert(p - begin(), basic_string(first, last, get_allocator()))`.
+*Returns:* An iterator which refers to the first inserted character, or
+`p` if `first == last`.
 ``` cpp
+constexpr iterator insert(const_iterator p, initializer_list<charT> il);
 ```
+*Effects:* Equivalent to: `return insert(p, il.begin(), il.end());`
 ##### `basic_string::erase` <a id="string.erase">[[string.erase]]</a>
 ``` cpp
+constexpr basic_string& erase(size_type pos = 0, size_type n = npos);
 ```
 *Throws:* `out_of_range` if `pos` `> size()`.
 *Effects:* Determines the effective length `xlen` of the string to be
+removed as the smaller of `n` and `size() - pos`. Removes the characters
+in the range \[`begin() + pos`, `begin() + pos + xlen`).
 *Returns:* `*this`.
 ``` cpp
+constexpr iterator erase(const_iterator p);
 ```
+*Preconditions:* `p` is a valid dereferenceable iterator on `*this`.
 *Throws:* Nothing.
 *Effects:* Removes the character referred to by `p`.
 *Returns:* An iterator which points to the element immediately following
 `p` prior to the element being erased. If no such element exists,
 `end()` is returned.
 ``` cpp
+constexpr iterator erase(const_iterator first, const_iterator last);
 ```
+*Preconditions:* `first` and `last` are valid iterators on `*this`.
+\[`first`, `last`) is a valid range.
 *Throws:* Nothing.
 *Effects:* Removes the characters in the range `[first, last)`.
 *Returns:* An iterator which points to the element pointed to by `last`
 prior to the other elements being erased. If no such element exists,
 `end()` is returned.
 ``` cpp
+constexpr void pop_back();
 ```
+*Preconditions:* `!empty()`.
 *Throws:* Nothing.
+*Effects:* Equivalent to `erase(end() - 1)`.
 ##### `basic_string::replace` <a id="string.replace">[[string.replace]]</a>
 ``` cpp
+constexpr basic_string& replace(size_type pos1, size_type n1, const basic_string& str);
 ```
 *Effects:* Equivalent to:
 `return replace(pos1, n1, str.data(), str.size());`
 ``` cpp
+constexpr basic_string& replace(size_type pos1, size_type n1, const basic_string& str,
                                 size_type pos2, size_type n2 = npos);
 ```
+*Effects:* Equivalent to:
+``` cpp
+return replace(pos1, n1, basic_string_view<charT, traits>(str).substr(pos2, n2));
+```
 ``` cpp
+template<class T>
+  constexpr basic_string& replace(size_type pos1, size_type n1, const T& t);
 ```
+*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> sv = t;
+return replace(pos1, n1, sv.data(), sv.size());
+```
 ``` cpp
 template<class T>
+ constexpr basic_string& replace(size_type pos1, size_type n1, const T& t,
                                   size_type pos2, size_type n2 = npos);
 ```
+*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> sv = t;
+return replace(pos1, n1, sv.substr(pos2, n2));
+```
 ``` cpp
+constexpr basic_string& replace(size_type pos1, size_type n1, const charT* s, size_type n2);
 ```
+*Preconditions:* \[`s`, `s + n2`) is a valid range.
+*Throws:*
+- `out_of_range` if `pos1 > size()`,
+- `length_error` if the length of the resulting string would exceed
+  `max_size()` (see below), or
+- any exceptions thrown by `allocator_traits<Allocator>::allocate`.
 *Effects:* Determines the effective length `xlen` of the string to be
 removed as the smaller of `n1` and `size() - pos1`. If
 `size() - xlen >= max_size() - n2` throws `length_error`. Otherwise, the
+function replaces the characters in the range \[`begin() + pos1`,
+`begin() + pos1 + xlen`) with a copy of the range \[`s`, `s + n2`).
 *Returns:* `*this`.
 ``` cpp
+constexpr basic_string& replace(size_type pos, size_type n, const charT* s);
 ```
 *Effects:* Equivalent to:
 `return replace(pos, n, s, traits::length(s));`
 ``` cpp
+constexpr basic_string& replace(size_type pos1, size_type n1, size_type n2, charT c);
 ```
+*Throws:*
+- `out_of_range` if `pos1 > size()`,
+- `length_error` if the length of the resulting string would exceed
+  `max_size()` (see below), or
+- any exceptions thrown by `allocator_traits<Allocator>::allocate.`
+*Effects:* Determines the effective length `xlen` of the string to be
+removed as the smaller of `n1` and `size() - pos1`. If
+`size() - xlen >=` `max_size() - n2` throws `length_error`. Otherwise,
+the function replaces the characters in the range \[`begin() + pos1`,
+`begin() + pos1 + xlen`) with `n2` copies of `c`.
 *Returns:* `*this`.
 ``` cpp
+constexpr basic_string& replace(const_iterator i1, const_iterator i2, const basic_string& str);
 ```
+*Effects:* Equivalent to:
+`return replace(i1, i2, basic_string_view<charT, traits>(str));`
 ``` cpp
+template<class T>
+  constexpr basic_string& replace(const_iterator i1, const_iterator i2, const T& t);
 ```
+*Constraints:*
+- `is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+  `true` and
+- `is_convertible_v<const T&, const charT*>` is `false`.
+*Preconditions:* \[`begin()`, `i1`) and \[`i1`, `i2`) are valid ranges.
+*Effects:* Equivalent to:
 ``` cpp
+basic_string_view<charT, traits> sv = t;
+return replace(i1 - begin(), i2 - i1, sv.data(), sv.size());
 ```
 ``` cpp
+constexpr basic_string& replace(const_iterator i1, const_iterator i2, const charT* s, size_type n);
 ```
+*Effects:* Equivalent to:
+`return replace(i1, i2, basic_string_view<charT, traits>(s, n));`
+``` cpp
+constexpr basic_string& replace(const_iterator i1, const_iterator i2, const charT* s);
+```
+*Effects:* Equivalent to:
+`return replace(i1, i2, basic_string_view<charT, traits>(s));`
 ``` cpp
+constexpr basic_string& replace(const_iterator i1, const_iterator i2, size_type n, charT c);
 ```
+*Preconditions:* \[`begin()`, `i1`) and \[`i1`, `i2`) are valid ranges.
+*Effects:* Equivalent to: `return replace(i1 - begin(), i2 - i1, n, c);`
 ``` cpp
 template<class InputIterator>
+ constexpr basic_string& replace(const_iterator i1, const_iterator i2,
                                   InputIterator j1, InputIterator j2);
 ```
+*Constraints:* `InputIterator` is a type that qualifies as an input
+iterator [[container.requirements.general]].
+*Effects:* Equivalent to:
+`return replace(i1, i2, basic_string(j1, j2, get_allocator()));`
 ``` cpp
+constexpr basic_string& replace(const_iterator i1, const_iterator i2, initializer_list<charT> il);
 ```
+*Effects:* Equivalent to:
+`return replace(i1, i2, il.begin(), il.size());`
 ##### `basic_string::copy` <a id="string.copy">[[string.copy]]</a>
 ``` cpp
+constexpr size_type copy(charT* s, size_type n, size_type pos = 0) const;
 ```
+*Effects:* Equivalent to:
+`return basic_string_view<charT, traits>(*this).copy(s, n, pos);`
 [*Note 1*: This does not terminate `s` with a null
 object. — *end note*]
 ##### `basic_string::swap` <a id="string.swap">[[string.swap]]</a>
 ``` cpp
+constexpr void swap(basic_string& s)
   noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
            allocator_traits<Allocator>::is_always_equal::value);
 ```
+*Preconditions:*
+`allocator_traits<Allocator>::propagate_on_container_swap::value` is
+`true` or `get_allocator() == s.get_allocator()`.
+*Ensures:* `*this` contains the same sequence of characters that was in
+`s`, `s` contains the same sequence of characters that was in `*this`.
 *Throws:* Nothing.
 *Complexity:* Constant time.

Diff to HTML by rtfpessoa