20 Strings library [strings]

20.3 String classes [string.classes]

20.3.2 Class template basic_­string [basic.string]

20.3.2.7 String operations [string.ops]

20.3.2.7.1 Accessors [string.accessors]

🔗
const charT* c_str() const noexcept; const charT* data() const noexcept;
1
#
Returns: A pointer p such that p + i == &operator[](i) for each i in [0, size()].
2
#
Complexity: Constant time.
3
#
Requires: The program shall not alter any of the values stored in the character array.
🔗
charT* data() noexcept;
4
#
Returns: A pointer p such that p + i == &operator[](i) for each i in [0, size()].
5
#
Complexity: Constant time.
6
#
Requires: The program shall not alter the value stored at p + size().
🔗
operator basic_string_view<charT, traits>() const noexcept;
7
#
Effects: Equivalent to: return basic_­string_­view<charT, traits>(data(), size());
🔗
allocator_type get_allocator() const noexcept;
8
#
Returns: A copy of the Allocator object used to construct the string or, if that allocator has been replaced, a copy of the most recent replacement.

20.3.2.7.2 basic_­string​::​find [string.find]

🔗
template<class T> size_type find(const T& t, size_type pos = 0) const;
1
#
Effects: Creates a variable, sv, as if by basic_­string_­view<charT, traits> sv = t; and then determines the lowest position xpos, if possible, such that both of the following conditions hold:
  • (1.1)
    pos <= xpos and xpos + sv.size() <= size();
  • (1.2)
    traits​::​eq(at(xpos + I), sv.at(I)) for all elements I of the data referenced by sv.
2
#
Returns: xpos if the function can determine such a value for xpos.
Otherwise, returns npos.
3
#
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.
4
#
Throws: Nothing unless the initialization of sv throws an exception.
🔗
size_type find(const basic_string& str, size_type pos = 0) const noexcept;
5
#
Effects: Equivalent to: return find(basic_­string_­view<charT, traits>(str), pos);
🔗
size_type find(const charT* s, size_type pos, size_type n) const;
6
#
Returns: find(basic_­string_­view<charT, traits>(s, n), pos).
🔗
size_type find(const charT* s, size_type pos = 0) const;
7
#
Requires: s points to an array of at least traits​::​length(s) + 1 elements of charT.
8
#
Returns: find(basic_­string_­view<charT, traits>(s), pos).
🔗
size_type find(charT c, size_type pos = 0) const;
9
#
Returns: find(basic_­string(1, c), pos).

20.3.2.7.3 basic_­string​::​rfind [string.rfind]

🔗
template<class T> size_type rfind(const T& t, size_type pos = npos) const;
1
#
Effects: Creates a variable, sv, as if by basic_­string_­view<charT, traits> sv = t; and then determines the highest position xpos, if possible, such that both of the following conditions hold:
  • (1.1)
    xpos <= pos and xpos + sv.size() <= size();
  • (1.2)
    traits​::​eq(at(xpos + I), sv.at(I)) for all elements I of the data referenced by sv.
2
#
Returns: xpos if the function can determine such a value for xpos.
Otherwise, returns npos.
3
#
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.
4
#
Throws: Nothing unless the initialization of sv throws an exception.
🔗
size_type rfind(const basic_string& str, size_type pos = npos) const noexcept;
5
#
Effects: Equivalent to: return rfind(basic_­string_­view<charT, traits>(str), pos);
🔗
size_type rfind(const charT* s, size_type pos, size_type n) const;
6
#
Returns: rfind(basic_­string_­view<charT, traits>(s, n), pos).
🔗
size_type rfind(const charT* s, size_type pos = npos) const;
7
#
Requires: s points to an array of at least traits​::​length(s) + 1 elements of charT.
8
#
Returns: rfind(basic_­string_­view<charT, traits>(s), pos).
🔗
size_type rfind(charT c, size_type pos = npos) const;
9
#
Returns: rfind(basic_­string(1, c), pos).

20.3.2.7.4 basic_­string​::​find_­first_­of [string.find.first.of]

🔗
template<class T> size_type find_first_of(const T& t, size_type pos = 0) const;
1
#
Effects: Creates a variable, sv, as if by basic_­string_­view<charT, traits> sv = t; and then determines the lowest position xpos, if possible, such that both of the following conditions hold:
  • (1.1)
    pos <= xpos and xpos < size();
  • (1.2)
    traits​::​eq(at(xpos), sv.at(I)) for some element I of the data referenced by sv.
2
#
Returns: xpos if the function can determine such a value for xpos.
Otherwise, returns npos.
3
#
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.
4
#
Throws: Nothing unless the initialization of sv throws an exception.
🔗
size_type find_first_of(const basic_string& str, size_type pos = 0) const noexcept;
5
#
Effects: Equivalent to: return find_­first_­of(basic_­string_­view<charT, traits>(str), pos);
🔗
size_type find_first_of(const charT* s, size_type pos, size_type n) const;
6
#
Returns: find_­first_­of(basic_­string_­view<charT, traits>(s, n), pos).
🔗
size_type find_first_of(const charT* s, size_type pos = 0) const;
7
#
Requires: s points to an array of at least traits​::​length(s) + 1 elements of charT.
8
#
Returns: find_­first_­of(basic_­string_­view<charT, traits>(s), pos).
🔗
size_type find_first_of(charT c, size_type pos = 0) const;
9
#
Returns: find_­first_­of(basic_­string(1, c), pos).

20.3.2.7.5 basic_­string​::​find_­last_­of [string.find.last.of]

🔗
template<class T> size_type find_last_of(const T& t, size_type pos = npos) const;
1
#
Effects: Creates a variable, sv, as if by basic_­string_­view<charT, traits> sv = t; and then determines the highest position xpos, if possible, such that both of the following conditions hold:
  • (1.1)
    xpos <= pos and xpos < size();
  • (1.2)
    traits​::​eq(at(xpos), sv.at(I)) for some element I of the data referenced by sv.
2
#
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.
3
#
Throws: Nothing unless the initialization of sv throws an exception.
4
#
Returns: xpos if the function can determine such a value for xpos.
Otherwise, returns npos.
🔗
size_type find_last_of(const basic_string& str, size_type pos = npos) const noexcept;
5
#
Effects: Equivalent to: return find_­last_­of(basic_­string_­view<charT, traits>(str), pos);
🔗
size_type find_last_of(const charT* s, size_type pos, size_type n) const;
6
#
Returns: find_­last_­of(basic_­string_­view<charT, traits>(s, n), pos).
🔗
size_type find_last_of(const charT* s, size_type pos = npos) const;
7
#
Requires: s points to an array of at least traits​::​length(s) + 1 elements of charT.
8
#
Returns: find_­last_­of(basic_­string_­view<charT, traits>(s), pos).
🔗
size_type find_last_of(charT c, size_type pos = npos) const;
9
#
Returns: find_­last_­of(basic_­string(1, c), pos).

20.3.2.7.6 basic_­string​::​find_­first_­not_­of [string.find.first.not.of]

🔗
template<class T> size_type find_first_not_of(const T& t, size_type pos = 0) const;
1
#
Effects: Creates a variable, sv, as if by basic_­string_­view<charT, traits> sv = t; and then determines the lowest position xpos, if possible, such that both of the following conditions hold:
  • (1.1)
    pos <= xpos and xpos < size();
  • (1.2)
    traits​::​eq(at(xpos), sv.at(I)) for no element I of the data referenced by sv.
2
#
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.
3
#
Throws: Nothing unless the initialization of sv throws an exception.
4
#
Returns: xpos if the function can determine such a value for xpos.
Otherwise, returns npos.
🔗
size_type find_first_not_of(const basic_string& str, size_type pos = 0) const noexcept;
5
#
Effects: Equivalent to: 
return find_first_not_of(basic_string_view<charT, traits>(str), pos);
🔗
size_type find_first_not_of(const charT* s, size_type pos, size_type n) const;
6
#
Returns: find_­first_­not_­of(basic_­string_­view<charT, traits>(s, n), pos).
🔗
size_type find_first_not_of(const charT* s, size_type pos = 0) const;
7
#
Requires: s points to an array of at least traits​::​length(s) + 1 elements of charT.
8
#
Returns: find_­first_­not_­of(basic_­string_­view<charT, traits>(s), pos).
🔗
size_type find_first_not_of(charT c, size_type pos = 0) const;
9
#
Returns: find_­first_­not_­of(basic_­string(1, c), pos).

20.3.2.7.7 basic_­string​::​find_­last_­not_­of [string.find.last.not.of]

🔗
template<class T> size_type find_last_not_of(const T& t, size_type pos = npos) const;
1
#
Effects: Creates a variable, sv, as if by basic_­string_­view<charT, traits> sv = t; and then determines the highest position xpos, if possible, such that both of the following conditions hold:
  • (1.1)
    xpos <= pos and xpos < size();
  • (1.2)
    traits​::​eq(at(xpos), sv.at(I)) for no element I of the data referenced by sv.
2
#
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.
3
#
Throws: Nothing unless the initialization of sv throws an exception.
4
#
Returns: xpos if the function can determine such a value for xpos.
Otherwise, returns npos.
🔗
size_type find_last_not_of(const basic_string& str, size_type pos = npos) const noexcept;
5
#
Effects: Equivalent to: 
return find_last_not_of(basic_string_view<charT, traits>(str), pos);
🔗
size_type find_last_not_of(const charT* s, size_type pos, size_type n) const;
6
#
Returns: find_­last_­not_­of(basic_­string_­view<charT, traits>(s, n), pos).
🔗
size_type find_last_not_of(const charT* s, size_type pos = npos) const;
7
#
Requires: s points to an array of at least traits​::​length(s) + 1 elements of charT.
8
#
Returns: find_­last_­not_­of(basic_­string_­view<charT, traits>(s), pos).
🔗
size_type find_last_not_of(charT c, size_type pos = npos) const;
9
#
Returns: find_­last_­not_­of(basic_­string(1, c), pos).

20.3.2.7.8 basic_­string​::​substr [string.substr]

🔗
basic_string substr(size_type pos = 0, size_type n = npos) const;
1
#
Throws: out_­of_­range if pos > size().
2
#
Effects: Determines the effective length rlen of the string to copy as the smaller of n and size() - pos.
3
#
Returns: basic_­string(data()+pos, rlen).

20.3.2.7.9 basic_­string​::​compare [string.compare]

🔗
template<class T> int compare(const T& t) const;
1
#
Effects: Creates a variable, sv, as if by basic_­string_­view<charT, traits> sv = t; and then determines the effective length rlen of the strings to compare as the smaller of size() and sv.size().
The function then compares the two strings by calling traits​::​compare(data(), sv.data(), rlen).
2
#
Returns: The nonzero result if the result of the comparison is nonzero.
Otherwise, returns a value as indicated in Table 58.
Table 58 — compare() results
Condition
Return Value
size() <  sv.size()
< 0
size() == sv.size()
 0
size() >  sv.size()
> 0
3
#
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.
4
#
Throws: Nothing unless the initialization of sv throws an exception.
🔗
template<class T> int compare(size_type pos1, size_type n1, const T& t) const;
5
#
Effects: Equivalent to: 
{
  basic_string_view<charT, traits> sv = t;
  return basic_string_view<charT, traits>(data(), size()).substr(pos1, n1).compare(sv);
}
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> int compare(size_type pos1, size_type n1, const T& t, size_type pos2, size_type n2 = npos) const;
7
#
Effects: Equivalent to: 
basic_string_view<charT, traits> sv = t;
return basic_string_view<charT, traits>(
    data(), size()).substr(pos1, n1).compare(sv.substr(pos2, n2));
8
#
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.
🔗
int compare(const basic_string& str) const noexcept;
9
#
Effects: Equivalent to: return compare(basic_­string_­view<charT, traits>(str));
🔗
int compare(size_type pos1, size_type n1, const basic_string& str) const;
10
#
Effects: Equivalent to: return compare(pos1, n1, basic_­string_­view<charT, traits>(str));
🔗
int compare(size_type pos1, size_type n1, const basic_string& str, size_type pos2, size_type n2 = npos) const;
11
#
Effects: Equivalent to: 
return compare(pos1, n1, basic_string_view<charT, traits>(str), pos2, n2);
🔗
int compare(const charT* s) const;
12
#
Returns: compare(basic_­string(s)).
🔗
int compare(size_type pos, size_type n1, const charT* s) const;
13
#
Returns: basic_­string(*this, pos, n1).compare(basic_­string(s)).
🔗
int compare(size_type pos, size_type n1, const charT* s, size_type n2) const;
14
#
Returns: basic_­string(*this, pos, n1).compare(basic_­string(s, n2)).

20.3.2.7.10 basic_­string​::​starts_­with [string.starts.with]

🔗
bool starts_with(basic_string_view<charT, traits> x) const noexcept; bool starts_with(charT x) const noexcept; bool starts_with(const charT* x) const;
1
#
Effects: Equivalent to: 
return basic_string_view<charT, traits>(data(), size()).starts_with(x);

20.3.2.7.11 basic_­string​::​ends_­with [string.ends.with]

🔗
bool ends_with(basic_string_view<charT, traits> x) const noexcept; bool ends_with(charT x) const noexcept; bool ends_with(const charT* x) const;
1
#
Effects: Equivalent to: 
return basic_string_view<charT, traits>(data(), size()).ends_with(x);