20 Strings library [strings]

20.3 String classes [string.classes]

20.3.2 Class template basic_­string [basic.string]

20.3.2.6 Modifiers [string.modifiers]

20.3.2.6.1 basic_­string​::​operator+= [string.op+=]

🔗
basic_string& operator+=(const basic_string& str);
1
#
Effects: Calls append(str).
2
#
Returns: *this.
🔗
template<class T> basic_string& operator+=(const T& t);
3
#
Effects: Creates a variable, sv, as if by basic_­string_­view<charT, traits> sv = t; and then calls append(sv).
4
#
Returns: *this.
5
#
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.
🔗
basic_string& operator+=(const charT* s);
6
#
Effects: Calls append(s).
7
#
Returns: *this.
🔗
basic_string& operator+=(charT c);
8
#
Effects: Calls push_­back(c);
9
#
Returns: *this.
🔗
basic_string& operator+=(initializer_list<charT> il);
10
#
Effects: Calls append(il).
11
#
Returns: *this.

20.3.2.6.2 basic_­string​::​append [string.append]

🔗
basic_string& append(const basic_string& str);
1
#
Effects: Calls append(str.data(), str.size()).
2
#
Returns: *this.
🔗
basic_string& append(const basic_string& str, size_type pos, size_type n = npos);
3
#
Throws: out_­of_­range if pos > str.size().
4
#
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).
5
#
Returns: *this.
🔗
template<class T> basic_string& append(const T& t);
6
#
Effects: Equivalent to: 
{
  basic_string_view<charT, traits> sv = t;
  return append(sv.data(), sv.size());
}
7
#
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.
🔗
template<class T> basic_string& append(const T& t, size_type pos, size_type n = npos);
8
#
Throws: out_­of_­range if pos > sv.size().
9
#
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).
10
#
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.
11
#
Returns: *this.
🔗
basic_string& append(const charT* s, size_type n);
12
#
Requires: s points to an array of at least n elements of charT.
13
#
Throws: length_­error if size() + n > max_­size().
14
#
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.
15
#
Returns: *this.
🔗
basic_string& append(const charT* s);
16
#
Requires: s points to an array of at least traits​::​length(s) + 1 elements of charT.
17
#
Effects: Calls append(s, traits​::​length(s)).
18
#
Returns: *this.
🔗
basic_string& append(size_type n, charT c);
19
#
Effects: Equivalent to: return append(basic_­string(n, c));
🔗
template<class InputIterator> basic_string& append(InputIterator first, InputIterator last);
20
#
Requires: [first, last) is a valid range.
21
#
Effects: Equivalent to: return append(basic_­string(first, last, get_­allocator()));
🔗
basic_string& append(initializer_list<charT> il);
22
#
Effects: Calls append(il.begin(), il.size()).
23
#
Returns: *this.
🔗
void push_back(charT c);
24
#
Effects: Equivalent to append(static_­cast<size_­type>(1), c).

20.3.2.6.3 basic_­string​::​assign [string.assign]

🔗
basic_string& assign(const basic_string& str);
1
#
Effects: Equivalent to: return *this = str;
🔗
basic_string& assign(basic_string&& str) noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value || allocator_traits<Allocator>::is_always_equal::value);
2
#
Effects: Equivalent to: return *this = std​::​move(str);
🔗
basic_string& assign(const basic_string& str, size_type pos, size_type n = npos);
3
#
Throws: out_­of_­range if pos > str.size().
4
#
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).
5
#
Returns: *this.
🔗
template<class T> basic_string& assign(const T& t);
6
#
Effects: Equivalent to: 
{
  basic_string_view<charT, traits> sv = t;
  return assign(sv.data(), sv.size());
}
7
#
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.
🔗
template<class T> basic_string& assign(const T& t, size_type pos, size_type n = npos);
8
#
Throws: out_­of_­range if pos > sv.size().
9
#
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).
10
#
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.
11
#
Returns: *this.
🔗
basic_string& assign(const charT* s, size_type n);
12
#
Requires: s points to an array of at least n elements of charT.
13
#
Throws: length_­error if n > max_­size().
14
#
Effects: Replaces the string controlled by *this with a string of length n whose elements are a copy of those pointed to by s.
15
#
Returns: *this.
🔗
basic_string& assign(const charT* s);
16
#
Requires: s points to an array of at least traits​::​length(s) + 1 elements of charT.
17
#
Effects: Calls assign(s, traits​::​length(s)).
18
#
Returns: *this.
🔗
basic_string& assign(initializer_list<charT> il);
19
#
Effects: Calls assign(il.begin(), il.size()).
20
#
Returns: *this.
🔗
basic_string& assign(size_type n, charT c);
21
#
Effects: Equivalent to: return assign(basic_­string(n, c));
🔗
template<class InputIterator> basic_string& assign(InputIterator first, InputIterator last);
22
#
Effects: Equivalent to: return assign(basic_­string(first, last, get_­allocator()));

20.3.2.6.4 basic_­string​::​insert [string.insert]

🔗
basic_string& insert(size_type pos, const basic_string& str);
1
#
Effects: Equivalent to: return insert(pos, str.data(), str.size());
🔗
basic_string& insert(size_type pos1, const basic_string& str, size_type pos2, size_type n = npos);
2
#
Throws: out_­of_­range if pos1 > size() or pos2 > str.size().
3
#
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).
4
#
Returns: *this.
🔗
template<class T> basic_string& insert(size_type pos, const T& t);
5
#
Effects: Equivalent to: 
{
  basic_string_view<charT, traits> sv = t;
  return insert(pos, sv.data(), sv.size());
}
6
#
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.
🔗
template<class T> basic_string& insert(size_type pos1, const T& t, size_type pos2, size_type n = npos);
7
#
Throws: out_­of_­range if pos1 > size() or pos2 > sv.size().
8
#
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).
9
#
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.
10
#
Returns: *this.
🔗
basic_string& insert(size_type pos, const charT* s, size_type n);
11
#
Requires: s points to an array of at least n elements of charT.
12
#
Throws: out_­of_­range if pos > size() or length_­error if size() + n > max_­size().
13
#
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.
14
#
Returns: *this.
🔗
basic_string& insert(size_type pos, const charT* s);
15
#
Requires: s points to an array of at least traits​::​length(s) + 1 elements of charT.
16
#
Effects: Equivalent to: return insert(pos, s, traits​::​length(s));
🔗
basic_string& insert(size_type pos, size_type n, charT c);
17
#
Effects: Equivalent to: return insert(pos, basic_­string(n, c));
🔗
iterator insert(const_iterator p, charT c);
18
#
Requires: p is a valid iterator on *this.
19
#
Effects: Inserts a copy of c before the character referred to by p.
20
#
Returns: An iterator which refers to the copy of the inserted character.
🔗
iterator insert(const_iterator p, size_type n, charT c);
21
#
Requires: p is a valid iterator on *this.
22
#
Effects: Inserts n copies of c before the character referred to by p.
23
#
Returns: An iterator which refers to the copy of the first inserted character, or p if n == 0.
🔗
template<class InputIterator> iterator insert(const_iterator p, InputIterator first, InputIterator last);
24
#
Requires: p is a valid iterator on *this.
[first, last) is a valid range.
25
#
Effects: Equivalent to insert(p - begin(), basic_­string(first, last, get_­allocator())).
26
#
Returns: An iterator which refers to the copy of the first inserted character, or p if first == last.
🔗
iterator insert(const_iterator p, initializer_list<charT> il);
27
#
Effects: As if by insert(p, il.begin(), il.end()).
28
#
Returns: An iterator which refers to the copy of the first inserted character, or p if i1 is empty.

20.3.2.6.5 basic_­string​::​erase [string.erase]

🔗
basic_string& erase(size_type pos = 0, size_type n = npos);
1
#
Throws: out_­of_­range if pos > size().
2
#
Effects: Determines the effective length xlen of the string to be removed as the smaller of n and size() - pos.
3
#
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.
4
#
Returns: *this.
🔗
iterator erase(const_iterator p);
5
#
Throws: Nothing.
6
#
Effects: Removes the character referred to by p.
7
#
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.
🔗
iterator erase(const_iterator first, const_iterator last);
8
#
Requires: first and last are valid iterators on *this, defining a range [first, last).
9
#
Throws: Nothing.
10
#
Effects: Removes the characters in the range [first, last).
11
#
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.
🔗
void pop_back();
12
#
Requires: !empty().
13
#
Throws: Nothing.
14
#
Effects: Equivalent to erase(size() - 1, 1).

20.3.2.6.6 basic_­string​::​replace [string.replace]

🔗
basic_string& replace(size_type pos1, size_type n1, const basic_string& str);
1
#
Effects: Equivalent to: return replace(pos1, n1, str.data(), str.size());
🔗
basic_string& replace(size_type pos1, size_type n1, const basic_string& str, size_type pos2, size_type n2 = npos);
2
#
Throws: out_­of_­range if pos1 > size() or pos2 > str.size().
3
#
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).
4
#
Returns: *this.
🔗
template<class T> basic_string& replace(size_type pos1, size_type n1, const T& t);
5
#
Effects: Equivalent to: 
{
  basic_string_view<charT, traits> sv = t;
  return replace(pos1, n1, sv.data(), sv.size());
}
6
#
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.
🔗
template<class T> basic_string& replace(size_type pos1, size_type n1, const T& t, size_type pos2, size_type n2 = npos);
7
#
Throws: out_­of_­range if pos1 > size() or pos2 > sv.size().
8
#
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).
9
#
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.
10
#
Returns: *this.
🔗
basic_string& replace(size_type pos1, size_type n1, const charT* s, size_type n2);
11
#
Requires: s points to an array of at least n2 elements of charT.
12
#
Throws: out_­of_­range if pos1 > size() or length_­error if the length of the resulting string would exceed max_­size() (see below).
13
#
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.
14
#
Returns: *this.
🔗
basic_string& replace(size_type pos, size_type n, const charT* s);
15
#
Requires: s points to an array of at least traits​::​length(s) + 1 elements of charT.
16
#
Effects: Equivalent to: return replace(pos, n, s, traits​::​length(s));
🔗
basic_string& replace(size_type pos1, size_type n1, size_type n2, charT c);
17
#
Effects: Equivalent to: return replace(pos1, n1, basic_­string(n2, c));
🔗
basic_string& replace(const_iterator i1, const_iterator i2, const basic_string& str);
18
#
Requires: [begin(), i1) and [i1, i2) are valid ranges.
19
#
Effects: Calls replace(i1 - begin(), i2 - i1, str).
20
#
Returns: *this.
🔗
template<class T> basic_string& replace(const_iterator i1, const_iterator i2, const T& t);
21
#
Requires: [begin(), i1) and [i1, i2) are valid ranges.
22
#
Effects: Creates a variable, sv, as if by basic_­string_­view<charT, traits> sv = t; and then calls replace(i1 - begin(), i2 - i1, sv).
23
#
Returns: *this.
24
#
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.
🔗
basic_string& replace(const_iterator i1, const_iterator i2, const charT* s, size_type n);
25
#
Requires: [begin(), i1) and [i1, i2) are valid ranges and s points to an array of at least n elements of charT.
26
#
Effects: Calls replace(i1 - begin(), i2 - i1, s, n).
27
#
Returns: *this.
🔗
basic_string& replace(const_iterator i1, const_iterator i2, const charT* s);
28
#
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.
29
#
Effects: Calls replace(i1 - begin(), i2 - i1, s, traits​::​length(s)).
30
#
Returns: *this.
🔗
basic_string& replace(const_iterator i1, const_iterator i2, size_type n, charT c);
31
#
Requires: [begin(), i1) and [i1, i2) are valid ranges.
32
#
Effects: Calls replace(i1 - begin(), i2 - i1, basic_­string(n, c)).
33
#
Returns: *this.
🔗
template<class InputIterator> basic_string& replace(const_iterator i1, const_iterator i2, InputIterator j1, InputIterator j2);
34
#
Requires: [begin(), i1), [i1, i2) and [j1, j2) are valid ranges.
35
#
Effects: Calls replace(i1 - begin(), i2 - i1, basic_­string(j1, j2, get_­allocator())).
36
#
Returns: *this.
🔗
basic_string& replace(const_iterator i1, const_iterator i2, initializer_list<charT> il);
37
#
Requires: [begin(), i1) and [i1, i2) are valid ranges.
38
#
Effects: Calls replace(i1 - begin(), i2 - i1, il.begin(), il.size()).
39
#
Returns: *this.

20.3.2.6.7 basic_­string​::​copy [string.copy]

🔗
size_type copy(charT* s, size_type n, size_type pos = 0) const;
1
#
Let rlen be the smaller of n and size() - pos.
2
#
Throws: out_­of_­range if pos > size().
3
#
Requires: [s, s + rlen) is a valid range.
4
#
Effects: Equivalent to traits​::​copy(s, data() + pos, rlen).
[ Note
:
This does not terminate s with a null object.
— end note
 ]
5
#
Returns: rlen.

20.3.2.6.8 basic_­string​::​swap [string.swap]

🔗
void swap(basic_string& s) noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value || allocator_traits<Allocator>::is_always_equal::value);
1
#
Ensures: *this contains the same sequence of characters that was in s, s contains the same sequence of characters that was in *this.
2
#
Throws: Nothing.
3
#
Complexity: Constant time.