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

Files changed (1) hide show

tmp/tmp54jn62x_/{from.md → to.md} +172 -76

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

@@ -1,18 +1,26 @@
-### `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+=(const charT* s);
 ```
 *Effects:* Calls `append(s)`.
@@ -33,11 +41,11 @@ 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);
 ```
@@ -49,20 +57,42 @@ basic_string&
 ``` cpp
 basic_string&
   append(const basic_string& str, size_type pos, size_type n = npos);
 ```
-*Requires:* `pos <= str.size()`
 *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(const charT* s, size_type n);
 ```
@@ -101,11 +131,12 @@ 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))`.
 *Returns:* `*this`.
 ``` cpp
 basic_string& append(initializer_list<charT> il);
@@ -119,43 +150,65 @@ basic_string& append(initializer_list<charT> il);
 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 `assign(str, 0, npos)`.
 *Returns:* `*this`.
 ``` cpp
-basic_string& assign(basic_string&& str) noexcept;
 ```
-*Effects:* The function replaces the string controlled by `*this` with a
-string of length `str.size()` whose elements are a copy of the string
-controlled by `str`. A valid implementation is `swap(str)`.
 *Returns:* `*this`.
 ``` cpp
 basic_string&
   assign(const basic_string& str, size_type pos,
          size_type n = npos);
 ```
-*Requires:* `pos <= str.size()`
 *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(const charT* s, size_type n);
@@ -200,54 +253,71 @@ basic_string& assign(size_type n, charT c);
 ``` cpp
 template<class InputIterator>
   basic_string& assign(InputIterator first, InputIterator last);
 ```
-*Effects:* Equivalent to `assign(basic_string(first, last))`.
 *Returns:* `*this`.
-#### `basic_string::insert` <a id="string::insert">[[string::insert]]</a>
 ``` cpp
 basic_string&
-  insert(size_type pos1,
          const basic_string& str);
 ```
-*Requires:* `pos <= size()`.
-*Throws:* `out_of_range` if `pos > size()`.
-*Effects:* Calls `insert(pos, str.data(), str.size())`.
-*Returns:* `*this`.
 ``` cpp
 basic_string&
   insert(size_type pos1,
          const basic_string& str,
          size_type pos2, size_type n = npos);
 ```
-*Requires:* `pos1 <= size()` and `pos2 <= str.size()`
 *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, const charT* s, size_type n);
 ```
-*Requires:* `s` points to an array of at least `n` elements of `charT`
-and `pos <= size()`.
 *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
@@ -262,16 +332,14 @@ by `*this`.
 ``` cpp
 basic_string&
   insert(size_type pos, const charT* s);
 ```
-*Requires:* `pos <= size()` and `s` points to an array of at least
-`traits::length(s) + 1` elements of `charT`.
-*Effects:* Equivalent to `insert(pos, s, traits::length(s))`.
-*Returns:* `*this`.
 ``` cpp
 basic_string&
   insert(size_type pos, size_type n, charT c);
 ```
@@ -284,11 +352,11 @@ basic_string&
 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.
@@ -296,11 +364,11 @@ character.
 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`.
@@ -311,32 +379,30 @@ template<class InputIterator>
 *Requires:* `p` is a valid iterator on `*this`. `[first, last)` is a
 valid range.
 *Effects:* Equivalent to
-`insert(p - begin(), basic_string(first, last))`.
 *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:* `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);
 ```
-*Requires:* `pos` ` <= size()`
 *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`.
@@ -352,11 +418,11 @@ string controlled by `*this` beginning at position `pos + xlen`.
 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.
@@ -367,66 +433,86 @@ 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);
 ```
-*Requires:* `pos1 <= size()`.
-*Throws:* `out_of_range` if `pos1 > size()`.
-*Effects:* Calls `replace(pos1, n1, str.data(), str.size())`.
-*Returns:* `*this`.
 ``` cpp
 basic_string&
   replace(size_type pos1, size_type n1,
           const basic_string& str,
           size_type pos2, size_type n2 = npos);
 ```
-*Requires:* `pos1 <= size()` and `pos2 <= str.size()`.
 *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, const charT* s, size_type n2);
 ```
-*Requires:* `pos1 <= size()` and `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
@@ -444,16 +530,15 @@ string controlled by `*this` beginning at position `pos + xlen`.
 ``` cpp
 basic_string&
   replace(size_type pos, size_type n, const charT* s);
 ```
-*Requires:* `pos <= size()` and `s` points to an array of at least
-`traits::length(s) + 1` elements of `charT`.
-*Effects:* Calls `replace(pos, n, s, traits::length(s))`.
-*Returns:* `*this`.
 ``` cpp
 basic_string&
   replace(size_type pos1, size_type n1,
           size_type n2, charT c);
@@ -471,10 +556,21 @@ basic_string& replace(const_iterator i1, const_iterator i2, const basic_string&
 *Effects:* Calls `replace(i1 - begin(), i2 - i1, str)`.
 *Returns:* `*this`.
 ``` cpp
 basic_string&
   replace(const_iterator i1, const_iterator i2, const charT* s, size_type n);
 ```
@@ -515,11 +611,12 @@ template<class InputIterator>
 ```
 *Requires:* \[`begin()`, `i1`), \[`i1`, `i2`) and \[`j1`, `j2`) are
 valid ranges.
-*Effects:* Calls `replace(i1 - begin(), i2 - i1, basic_string(j1, j2))`.
 *Returns:* `*this`.
 ``` cpp
 basic_string& replace(const_iterator i1, const_iterator i2,
@@ -531,41 +628,40 @@ basic_string& replace(const_iterator i1, const_iterator i2,
 *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;
 ```
-*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`. `s` shall designate an array
-of at least `rlen` elements.
-The function then replaces the string designated by `s` with a string of
-length `rlen` whose elements are a copy of the string controlled by
-`*this` beginning at position `pos`.
-The function does not append a null object to the string designated by
-`s`.
 *Returns:* `rlen`.
-#### `basic_string::swap` <a id="string::swap">[[string::swap]]</a>
 ``` cpp
-void swap(basic_string& s);
 ```
-`*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.

+#### `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)`.
 *Effects:* Calls `append(il)`.
 *Returns:* `*this`.
+##### `basic_string::append` <a id="string.append">[[string.append]]</a>
 ``` cpp
 basic_string&
   append(const basic_string& str);
 ```
 ``` 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);
 ```
   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);
 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);
 ``` 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
 ``` 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);
 ```
 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.
 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`.
 *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`.
 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.
 *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
 ``` 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:* 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`), \[`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,
 *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.

Diff to HTML by rtfpessoa