24 Strings library [strings]

24.1 General [strings.general]

1
#

В этом разделе описаны компоненты для управления последовательностями любых не-массивов POD type. Такие типы называются char-like types, а объекты символьных типов называются char-like objects или просто characters.

2
#

Следующие подпункты описывают класс характеристик символа, класс строки и утилиты последовательностей с нулевым символом в конце, как показано в таблице 53.

Таблица 53 - Сводка библиотеки строк
Подпункт Заголовок (ы)
[char.traits] Черты характера <string>
[string.classes] Строковые классы <string>
[string.view] Классы строковых представлений <string_­view>
<cctype>
<cwctype>
[c.strings] Утилиты для последовательностей с нулевым завершением <cstring>
<cwchar>
<cstdlib>
<cuchar>

24.2 Character traits [char.traits]

1
#

В этом подразделе определяются требования по классам , представляющих character traitsи определяет шаблон класса char_­traits<charT>, наряду с четырьмя специализациями, char_­traits<char>, char_­traits<char16_­t>,
char_­traits<char32_­t>, и char_­traits<wchar_­t>, которые удовлетворяют этим требованиям.

2
#

Большинство классов , указанных в пунктах [string.classes] и [input.output] нужен набор связанных типов и функций , чтобы завершить определение их семантики. Эти типы и функции предоставляются как набор членов typedef-names и функций в параметре шаблона, traits используемом каждым таким шаблоном. В этом подпункте определяется семантика этих членов.

3
#

Чтобы специализировать эти шаблоны для создания строки или класса iostream для обработки определенного типа контейнера символов CharT, этот и связанный с ним класс характеристик символов Traits передаются в виде пары параметров в строку или шаблон iostream как параметры charT и traits. Traits​::​char_­type должно быть таким же, как CharT.

4
#

Этот подраздел определяет шаблон класса, char_­traits<charT>и четыре явных специализаций этого, char_­traits<​char>, char_­traits<char16_­t>, char_­traits<char32_­t>, и char_­traits<wchar_­t>, все из которых появляются в заголовке <string> и удовлетворяют требования ниже.

24.2.1 Character traits requirements [char.traits.require]

1
#

В таблице 54, X обозначает класс черты , определяющий типы и функции для символьного типа контейнера CharT; c и d обозначают значения типа CharT; p и q обозначают значения типа const CharT*; s обозначает значение типа CharT*; n, i и j обозначают значения типа size_­t; e и f обозначают значения типа X​::​int_­type; pos обозначает значение типа X​::​pos_­type; state обозначает значение типа X​::​state_­type; и r обозначает lvalue типа CharT. Операции с Чертами не должны вызывать исключений.

Таблица 54 - Требования к характеристикам персонажей
ВыражениеТип возвратаУтверждение / примечаниеСложность
до / после состояния
X​::​char_­type charT (описано в [char.traits.typedefs]) время компиляции
X​::​int_­type (описано в [char.traits.typedefs]) время компиляции
X​::​off_­type (описано в [char.traits.typedefs]) время компиляции
X​::​pos_­type (описано в [char.traits.typedefs]) время компиляции
X​::​state_­type (описано в [char.traits.typedefs]) время компиляции
X​::​eq(c,d) bool Returns: следует ли c рассматривать как равное d. постоянный
X​::​lt(c,d) bool Returns: следует ли c рассматривать как меньшее, чем d. постоянный
X​::​compare(p,q,n) int Returns: 0 если для каждого i в [0,n), X​::​eq(p[i],q[i]) есть true; иначе, отрицательное значение , если для некоторых j ин [0,n), X​::​lt(p[j],q[j]) это true и для каждого i дюйма [0,j) X​::​eq(p[i],q[i]) является true; иначе положительное значение. линейный
X​::​length(p) size_­t Returns: самый маленький i такой что X​::​eq(p[i],charT()) есть true. линейный
X​::​find(p,n,c) const X​::​char_­type* Returns: наименьшее q в [p,p+n) таком, то X​::​eq(*q,c) есть true, в противном случае ноль. линейный
X​::​move(s,p,n) X​::​char_­type* для каждого i в [0,n), выполняет X​::​assign(s[i],p[i]). Копирует правильно даже там, где диапазоны [p,p+n) и [s,s+n) перекрываются.
Returns: s. 		линейный
X​::​copy(s,p,n) X​::​char_­type* Requires: p не в [s,s+n). Returns: s.
для каждого i в [0,n), выполняет X​::​assign(s[i],p[i]). 		линейный
X​::​assign(r,d) (не используется) назначает r=d. постоянный
X​::​assign(s,n,c) X​::​char_­type* для каждого i в [0,n), выполняет X​::​assign(s[i],c).
Returns: s. 		линейный
X​::​not_­eof(e) int_­type Returns: e если X​::​eq_­int_­type(e,X​::​eof()) есть false, в противном случае такое значение f , которое X​::​eq_­int_­type(f,X​::​eof()) есть false. постоянный
X​::​to_­char_­type(e) X​::​char_­type Returns: если для некоторых c, X​::​eq_­int_­type(e,X​::​to_­int_­type(c)) это true, c; иначе какое-то неопределенное значение. постоянный
X​::​to_­int_­type(c) X​::​int_­type Returns: некоторая ценность e, ограниченная определениями to_­char_­type и eq_­int_­type. постоянный
X​::​eq_­int_­type(e,f) bool Returns: для всех c и d, X​::​eq(c,d) равно X​::​eq_­int_­type(X​::​to_­int_­type(c), X​::​to_­int_­type(d)); в противном случае выдает true if e и f обе копии X​::​eof(); в противном случае уступает, false если одно из e и f является копией, X​::​eof() а другое - нет; в противном случае значение не указано. постоянный
X​::​eof() X​::​int_­type Returns: такое значение e , которое X​::​eq_­int_­type(e,X​::​to_­int_­type(c)) есть false для всех значений c. постоянный
2
#

Шаблон класса

template<class charT> struct char_traits;

должны быть<string> указаны в заголовке как основа для явных специализаций.

24.2.2 Traits typedefs [char.traits.typedefs]

using char_type = CHAR_T;

1
#

Тип char_­type используется для ссылки на тип символьного контейнера в реализации библиотечных классов, определенных в [string.classes] разделе и [input.output].

using int_type = INT_T;

2
#

Requires: Для определенного типа характера контейнера char_­type, связанный тип контейнера INT_­T должен быть типа или класса , который может представлять все допустимые символы , преобразованных из соответствующих char_­type значений, а также значение конца-файла eof(). Типint_­type представляет собой тип символьного контейнера, который может содержать конец файла, который будет использоваться в качестве возвращаемого типа функций-членов класса iostream.224

using off_type = implementation-defined; using pos_type = implementation-defined;

3
#

Requires: Требования к off_­type и pos_­type описаны в [iostreams.limits.pos] и [iostream.forward].

using state_type = STATE_T;

4
#

Requires: state_­type должны отвечать требованиям CopyAssignable, CopyConstructibleи DefaultConstructible типов.

224)

Если их eof() можно char_­type удержать, то некоторые операции iostreams могут дать удивительные результаты.

24.2.3 char_­traits specializations [char.traits.specializations]

namespace std {
  template<> struct char_traits<char>;
  template<> struct char_traits<char16_t>;
  template<> struct char_traits<char32_t>;
  template<> struct char_traits<wchar_t>;
}
1
#

Заголовок <string> определяет четыре специализации шаблона класса char_­traits: char_­traits<​char>, char_­traits<char16_­t>, char_­traits<char32_­t>, и char_­traits<wchar_­t>.

2
#

Требования к участникам этих специализаций приведены в п [char.traits.require].

24.2.3.1 struct char_­traits<char> [char.traits.specializations.char]

namespace std {
  template<> struct char_traits<char> {
    using char_type  = char;
    using int_type   = int;
    using off_type   = streamoff;
    using pos_type   = streampos;
    using state_type = mbstate_t;

    static constexpr void assign(char_type& c1, const char_type& c2) noexcept;
    static constexpr bool eq(char_type c1, char_type c2) noexcept;
    static constexpr bool lt(char_type c1, char_type c2) noexcept;

    static constexpr int compare(const char_type* s1, const char_type* s2, size_t n);
    static constexpr size_t length(const char_type* s);
    static constexpr const char_type* find(const char_type* s, size_t n,
                                           const char_type& a);
    static char_type* move(char_type* s1, const char_type* s2, size_t n);
    static char_type* copy(char_type* s1, const char_type* s2, size_t n);
    static char_type* assign(char_type* s, size_t n, char_type a);

    static constexpr int_type not_eof(int_type c) noexcept;
    static constexpr char_type to_char_type(int_type c) noexcept;
    static constexpr int_type to_int_type(char_type c) noexcept;
    static constexpr bool eq_int_type(int_type c1, int_type c2) noexcept;
    static constexpr int_type eof() noexcept;
  };
}
1
#

Определенные типы для int_­type, pos_­type, off_­typeи state_­type должно быть int, streampos, streamoffи mbstate_­t соответственно.

2
#

Типstreampos должен быть типом , определяемым реализацией, который удовлетворяет требованиям pos_­type в [iostreams.limits.pos] и [iostream.forward].

3
#

Типstreamoff должен быть типом , определяемым реализацией, который удовлетворяет требованиям off_­type в [iostreams.limits.pos] и [iostream.forward].

4
#

Тип mbstate_­t определяется <cwchar> и может представлять любое из состояний преобразования, которое может происходить в определяемом реализацией наборе поддерживаемых правил кодирования многобайтовых символов.

5
#

Член с двумя аргументами assign должен быть определен идентично встроенному оператору =. Члены с двумя аргументами eq и lt должны быть определены идентично встроенным операторам == и < типу unsigned char.

6
#

Член eof() должен вернуться EOF.

24.2.3.2 struct char_­traits<char16_­t> [char.traits.specializations.char16_t]

namespace std {
  template<> struct char_traits<char16_t> {
    using char_type  = char16_t;
    using int_type   = uint_least16_t;
    using off_type   = streamoff;
    using pos_type   = u16streampos;
    using state_type = mbstate_t;

    static constexpr void assign(char_type& c1, const char_type& c2) noexcept;
    static constexpr bool eq(char_type c1, char_type c2) noexcept;
    static constexpr bool lt(char_type c1, char_type c2) noexcept;

    static constexpr int compare(const char_type* s1, const char_type* s2, size_t n);
    static constexpr size_t length(const char_type* s);
    static constexpr const char_type* find(const char_type* s, size_t n,
                                           const char_type& a);
    static char_type* move(char_type* s1, const char_type* s2, size_t n);
    static char_type* copy(char_type* s1, const char_type* s2, size_t n);
    static char_type* assign(char_type* s, size_t n, char_type a);

    static constexpr int_type not_eof(int_type c) noexcept;
    static constexpr char_type to_char_type(int_type c) noexcept;
    static constexpr int_type to_int_type(char_type c) noexcept;
    static constexpr bool eq_int_type(int_type c1, int_type c2) noexcept;
    static constexpr int_type eof() noexcept;
  };
}
1
#

Типu16streampos должен быть типом , определяемым реализацией, который удовлетворяет требованиям pos_­type в [iostreams.limits.pos] и [iostream.forward].

2
#

Члены двух аргументов assign, eqи lt должны быть определены тождественны встроенными операторами =, ==и < соответственно.

3
#

Член eof() должен возвращать константу, определяемую реализацией, которая не может отображаться как допустимая кодовая единица UTF-16.

24.2.3.3 struct char_­traits<char32_­t> [char.traits.specializations.char32_t]

namespace std {
  template<> struct char_traits<char32_t> {
    using char_type  = char32_t;
    using int_type   = uint_least32_t;
    using off_type   = streamoff;
    using pos_type   = u32streampos;
    using state_type = mbstate_t;

    static constexpr void assign(char_type& c1, const char_type& c2) noexcept;
    static constexpr bool eq(char_type c1, char_type c2) noexcept;
    static constexpr bool lt(char_type c1, char_type c2) noexcept;

    static constexpr int compare(const char_type* s1, const char_type* s2, size_t n);
    static constexpr size_t length(const char_type* s);
    static constexpr const char_type* find(const char_type* s, size_t n,
                                           const char_type& a);
    static char_type* move(char_type* s1, const char_type* s2, size_t n);
    static char_type* copy(char_type* s1, const char_type* s2, size_t n);
    static char_type* assign(char_type* s, size_t n, char_type a);

    static constexpr int_type not_eof(int_type c) noexcept;
    static constexpr char_type to_char_type(int_type c) noexcept;
    static constexpr int_type to_int_type(char_type c) noexcept;
    static constexpr bool eq_int_type(int_type c1, int_type c2) noexcept;
    static constexpr int_type eof() noexcept;
  };
}
1
#

Типu32streampos должен быть типом , определяемым реализацией, который удовлетворяет требованиям pos_­type в [iostreams.limits.pos] и [iostream.forward].

2
#

Члены двух аргументов assign, eqи lt должны быть определены тождественны встроенными операторами =, ==и < соответственно.

3
#

Член eof() должен возвращать константу, определяемую реализацией, которая не может отображаться как кодовая точка Unicode.

24.2.3.4 struct char_­traits<wchar_­t> [char.traits.specializations.wchar.t]

namespace std {
  template<> struct char_traits<wchar_t> {
    using char_type  = wchar_t;
    using int_type   = wint_t;
    using off_type   = streamoff;
    using pos_type   = wstreampos;
    using state_type = mbstate_t;

    static constexpr void assign(char_type& c1, const char_type& c2) noexcept;
    static constexpr bool eq(char_type c1, char_type c2) noexcept;
    static constexpr bool lt(char_type c1, char_type c2) noexcept;

    static constexpr int compare(const char_type* s1, const char_type* s2, size_t n);
    static constexpr size_t length(const char_type* s);
    static constexpr const char_type* find(const char_type* s, size_t n,
                                           const char_type& a);
    static char_type* move(char_type* s1, const char_type* s2, size_t n);
    static char_type* copy(char_type* s1, const char_type* s2, size_t n);
    static char_type* assign(char_type* s, size_t n, char_type a);

    static constexpr int_type not_eof(int_type c) noexcept;
    static constexpr char_type to_char_type(int_type c) noexcept;
    static constexpr int_type to_int_type(char_type c) noexcept;
    static constexpr bool eq_int_type(int_type c1, int_type c2) noexcept;
    static constexpr int_type eof() noexcept;
  };
}
1
#

Определенные типы для int_­type, pos_­typeи state_­type должны быть wint_­t, wstreamposи mbstate_­t соответственно.

2
#

Типwstreampos должен быть типом , определяемым реализацией, который удовлетворяет требованиям pos_­type в [iostreams.limits.pos] и [iostream.forward].

3
#

Тип mbstate_­t определяется <cwchar> и может представлять любое из состояний преобразования, которое может происходить в определяемом реализацией наборе поддерживаемых правил кодирования многобайтовых символов.

4
#

Члены двух аргументов assign, eqи lt должны быть определены тождественны встроенными операторами =, ==и < соответственно.

5
#

Член eof() должен вернуться WEOF.

24.3 String classes [string.classes]

1
#

Заголовка <string> определяет basic_­string шаблон класса для манипулирования переменной длины последовательности углеродно как объекты и четыре typedef-names, string, u16string, u32string, и wstring, что имя специализации basic_­string<char>, basic_­string<char16_­t>, basic_­string<char32_­t>, и basic_­string<​wchar_­t>, соответственно.

24.3.1 Header <string> synopsis [string.syn]

#include <initializer_list>

namespace std {
  // [char.traits], character traits
  template<class charT> struct char_traits;
  template<> struct char_traits<char>;
  template<> struct char_traits<char16_t>;
  template<> struct char_traits<char32_t>;
  template<> struct char_traits<wchar_t>;

  // [basic.string], basic_­string
  template<class charT, class traits = char_traits<charT>,
    class Allocator = allocator<charT>>
      class basic_string;

  template<class charT, class traits, class Allocator>
    basic_string<charT, traits, Allocator>
      operator+(const basic_string<charT, traits, Allocator>& lhs,
                const basic_string<charT, traits, Allocator>& rhs);
  template<class charT, class traits, class Allocator>
    basic_string<charT, traits, Allocator>
      operator+(basic_string<charT, traits, Allocator>&& lhs,
                const basic_string<charT, traits, Allocator>& rhs);
  template<class charT, class traits, class Allocator>
    basic_string<charT, traits, Allocator>
      operator+(const basic_string<charT, traits, Allocator>& lhs,
                basic_string<charT, traits, Allocator>&& rhs);
  template<class charT, class traits, class Allocator>
    basic_string<charT, traits, Allocator>
      operator+(basic_string<charT, traits, Allocator>&& lhs,
                basic_string<charT, traits, Allocator>&& rhs);
  template<class charT, class traits, class Allocator>
    basic_string<charT, traits, Allocator>
      operator+(const charT* lhs,
                const basic_string<charT, traits, Allocator>& rhs);
  template<class charT, class traits, class Allocator>
    basic_string<charT, traits, Allocator>
      operator+(const charT* lhs,
                basic_string<charT, traits, Allocator>&& rhs);
  template<class charT, class traits, class Allocator>
    basic_string<charT, traits, Allocator>
      operator+(charT lhs, const basic_string<charT, traits, Allocator>& rhs);
  template<class charT, class traits, class Allocator>
    basic_string<charT, traits, Allocator>
      operator+(charT lhs, basic_string<charT, traits, Allocator>&& rhs);
  template<class charT, class traits, class Allocator>
    basic_string<charT, traits, Allocator>
      operator+(const basic_string<charT, traits, Allocator>& lhs,
                const charT* rhs);
  template<class charT, class traits, class Allocator>
    basic_string<charT, traits, Allocator>
      operator+(basic_string<charT, traits, Allocator>&& lhs,
                const charT* rhs);
  template<class charT, class traits, class Allocator>
    basic_string<charT, traits, Allocator>
      operator+(const basic_string<charT, traits, Allocator>& lhs, charT rhs);
  template<class charT, class traits, class Allocator>
    basic_string<charT, traits, Allocator>
      operator+(basic_string<charT, traits, Allocator>&& lhs, charT rhs);

  template<class charT, class traits, class Allocator>
    bool operator==(const basic_string<charT, traits, Allocator>& lhs,
                    const basic_string<charT, traits, Allocator>& rhs) noexcept;
  template<class charT, class traits, class Allocator>
    bool operator==(const charT* lhs,
                    const basic_string<charT, traits, Allocator>& rhs);
  template<class charT, class traits, class Allocator>
    bool operator==(const basic_string<charT, traits, Allocator>& lhs,
                    const charT* rhs);
  template<class charT, class traits, class Allocator>
    bool operator!=(const basic_string<charT, traits, Allocator>& lhs,
                    const basic_string<charT, traits, Allocator>& rhs) noexcept;
  template<class charT, class traits, class Allocator>
    bool operator!=(const charT* lhs,
                    const basic_string<charT, traits, Allocator>& rhs);
  template<class charT, class traits, class Allocator>
    bool operator!=(const basic_string<charT, traits, Allocator>& lhs,
                    const charT* rhs);

  template<class charT, class traits, class Allocator>
    bool operator< (const basic_string<charT, traits, Allocator>& lhs,
                    const basic_string<charT, traits, Allocator>& rhs) noexcept;
  template<class charT, class traits, class Allocator>
    bool operator< (const basic_string<charT, traits, Allocator>& lhs,
                    const charT* rhs);
  template<class charT, class traits, class Allocator>
    bool operator< (const charT* lhs,
                    const basic_string<charT, traits, Allocator>& rhs);
  template<class charT, class traits, class Allocator>
    bool operator> (const basic_string<charT, traits, Allocator>& lhs,
                    const basic_string<charT, traits, Allocator>& rhs) noexcept;
  template<class charT, class traits, class Allocator>
    bool operator> (const basic_string<charT, traits, Allocator>& lhs,
                    const charT* rhs);
  template<class charT, class traits, class Allocator>
    bool operator> (const charT* lhs,
                    const basic_string<charT, traits, Allocator>& rhs);

  template<class charT, class traits, class Allocator>
    bool operator<=(const basic_string<charT, traits, Allocator>& lhs,
                    const basic_string<charT, traits, Allocator>& rhs) noexcept;
  template<class charT, class traits, class Allocator>
    bool operator<=(const basic_string<charT, traits, Allocator>& lhs,
                    const charT* rhs);
  template<class charT, class traits, class Allocator>
    bool operator<=(const charT* lhs,
                    const basic_string<charT, traits, Allocator>& rhs);
  template<class charT, class traits, class Allocator>
    bool operator>=(const basic_string<charT, traits, Allocator>& lhs,
                    const basic_string<charT, traits, Allocator>& rhs) noexcept;
  template<class charT, class traits, class Allocator>
    bool operator>=(const basic_string<charT, traits, Allocator>& lhs,
                    const charT* rhs);
  template<class charT, class traits, class Allocator>
    bool operator>=(const charT* lhs,
                    const basic_string<charT, traits, Allocator>& rhs);

  // [string.special], swap
  template<class charT, class traits, class Allocator>
    void swap(basic_string<charT, traits, Allocator>& lhs,
              basic_string<charT, traits, Allocator>& rhs)
      noexcept(noexcept(lhs.swap(rhs)));

  // [string.io], inserters and extractors
  template<class charT, class traits, class Allocator>
    basic_istream<charT, traits>&
      operator>>(basic_istream<charT, traits>& is,
                 basic_string<charT, traits, Allocator>& str);
  template<class charT, class traits, class Allocator>
    basic_ostream<charT, traits>&
      operator<<(basic_ostream<charT, traits>& os,
                 const basic_string<charT, traits, Allocator>& str);
  template<class charT, class traits, class Allocator>
    basic_istream<charT, traits>&
      getline(basic_istream<charT, traits>& is,
              basic_string<charT, traits, Allocator>& str,
              charT delim);
  template<class charT, class traits, class Allocator>
    basic_istream<charT, traits>&
      getline(basic_istream<charT, traits>&& is,
              basic_string<charT, traits, Allocator>& str,
              charT delim);
  template<class charT, class traits, class Allocator>
    basic_istream<charT, traits>&
      getline(basic_istream<charT, traits>& is,
              basic_string<charT, traits, Allocator>& str);
  template<class charT, class traits, class Allocator>
    basic_istream<charT, traits>&
      getline(basic_istream<charT, traits>&& is,
              basic_string<charT, traits, Allocator>& str);

  // basic_­string typedef names
  using string    = basic_string<char>;
  using u16string = basic_string<char16_t>;
  using u32string = basic_string<char32_t>;
  using wstring   = basic_string<wchar_t>;

  // [string.conversions], numeric conversions
  int stoi(const string& str, size_t* idx = 0, int base = 10);
  long stol(const string& str, size_t* idx = 0, int base = 10);
  unsigned long stoul(const string& str, size_t* idx = 0, int base = 10);
  long long stoll(const string& str, size_t* idx = 0, int base = 10);
  unsigned long long stoull(const string& str, size_t* idx = 0, int base = 10);
  float stof(const string& str, size_t* idx = 0);
  double stod(const string& str, size_t* idx = 0);
  long double stold(const string& str, size_t* idx = 0);
  string to_string(int val);
  string to_string(unsigned val);
  string to_string(long val);
  string to_string(unsigned long val);
  string to_string(long long val);
  string to_string(unsigned long long val);
  string to_string(float val);
  string to_string(double val);
  string to_string(long double val);

  int stoi(const wstring& str, size_t* idx = 0, int base = 10);
  long stol(const wstring& str, size_t* idx = 0, int base = 10);
  unsigned long stoul(const wstring& str, size_t* idx = 0, int base = 10);
  long long stoll(const wstring& str, size_t* idx = 0, int base = 10);
  unsigned long long stoull(const wstring& str, size_t* idx = 0, int base = 10);
  float stof(const wstring& str, size_t* idx = 0);
  double stod(const wstring& str, size_t* idx = 0);
  long double stold(const wstring& str, size_t* idx = 0);
  wstring to_wstring(int val);
  wstring to_wstring(unsigned val);
  wstring to_wstring(long val);
  wstring to_wstring(unsigned long val);
  wstring to_wstring(long long val);
  wstring to_wstring(unsigned long long val);
  wstring to_wstring(float val);
  wstring to_wstring(double val);
  wstring to_wstring(long double val);

  // [basic.string.hash], hash support
  template<class T> struct hash;
  template<> struct hash<string>;
  template<> struct hash<u16string>;
  template<> struct hash<u32string>;
  template<> struct hash<wstring>;

  namespace pmr {
    template <class charT, class traits = char_traits<charT>>
      using basic_string =
        std::basic_string<charT, traits, polymorphic_allocator<charT>>;

    using string    = basic_string<char>;
    using u16string = basic_string<char16_t>;
    using u32string = basic_string<char32_t>;
    using wstring   = basic_string<wchar_t>;
  }

  inline namespace literals {
  inline namespace string_literals {
    // [basic.string.literals], suffix for basic_­string literals
    string    operator""s(const char* str, size_t len);
    u16string operator""s(const char16_t* str, size_t len);
    u32string operator""s(const char32_t* str, size_t len);
    wstring   operator""s(const wchar_t* str, size_t len);
  }
  }
}

24.3.2 Class template basic_­string [basic.string]

1
#

Шаблон класса basic_­string описывает объекты, которые могут хранить последовательность, состоящую из переменного числа произвольных char-подобных объектов, с первым элементом последовательности в нулевой позиции. Такая последовательность также называется «строкой», если тип char-подобных объектов, которые она содержит, ясен из контекста. В остальной части этого раздела тип char-подобных объектов, содержащихся в basic_­string объекте, обозначается с помощью charT.

2
#

Функции-члены basic_­string используют объект Allocator класса, переданный в качестве параметра шаблона, для выделения и освобождения памяти для содержащихся в нем объектов типа char.225

3
#

А basic_­string - это contiguous container.

4
#

Во всех случаях size() <= capacity().

5
#

Функции, описанные в этом пункте, могут сообщать о двух типах ошибок, каждый из которых связан с типом исключения:

namespace std {
  template<class charT, class traits = char_traits<charT>,
           class Allocator = allocator<charT>>
  class basic_string {
  public:
    // types:
    using traits_type            = traits;
    using value_type             = charT;
    using allocator_type         = Allocator;
    using size_type              = typename allocator_traits<Allocator>::size_type;
    using difference_type        = typename allocator_traits<Allocator>::difference_type;
    using pointer                = typename allocator_traits<Allocator>::pointer;
    using const_pointer          = typename allocator_traits<Allocator>::const_pointer;
    using reference              = value_type&;
    using const_reference        = const value_type&;

    using iterator               = implementation-defined; // see [container.requirements]
    using const_iterator         = implementation-defined; // see [container.requirements]
    using reverse_iterator       = std::reverse_iterator<iterator>;
    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
    static const size_type npos  = -1;

    // [string.cons], construct/copy/destroy
    basic_string() noexcept(noexcept(Allocator())) : basic_string(Allocator()) { }
    explicit basic_string(const Allocator& a) noexcept;
    basic_string(const basic_string& str);
    basic_string(basic_string&& str) noexcept;
    basic_string(const basic_string& str, size_type pos,
                 const Allocator& a = Allocator());
    basic_string(const basic_string& str, size_type pos, size_type n,
                 const Allocator& a = Allocator());
    template<class T>
      basic_string(const T& t, size_type pos, size_type n,
                   const Allocator& a = Allocator());
    explicit basic_string(basic_string_view<charT, traits> sv,
                          const Allocator& a = Allocator());
    basic_string(const charT* s,
                 size_type n, const Allocator& a = Allocator());
    basic_string(const charT* s, const Allocator& a = Allocator());
    basic_string(size_type n, charT c, const Allocator& a = Allocator());
    template<class InputIterator>
      basic_string(InputIterator begin, InputIterator end,
                   const Allocator& a = Allocator());
    basic_string(initializer_list<charT>, const Allocator& = Allocator());
    basic_string(const basic_string&, const Allocator&);
    basic_string(basic_string&&, const Allocator&);

    ~basic_string();
    basic_string& operator=(const basic_string& str);
    basic_string& operator=(basic_string&& str)
      noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
               allocator_traits<Allocator>::is_always_equal::value);
    basic_string& operator=(basic_string_view<charT, traits> sv);
    basic_string& operator=(const charT* s);
    basic_string& operator=(charT c);
    basic_string& operator=(initializer_list<charT>);

    // [string.iterators], iterators
    iterator       begin() noexcept;
    const_iterator begin() const noexcept;
    iterator       end() noexcept;
    const_iterator end() const noexcept;

    reverse_iterator       rbegin() noexcept;
    const_reverse_iterator rbegin() const noexcept;
    reverse_iterator       rend() noexcept;
    const_reverse_iterator rend() const noexcept;

    const_iterator         cbegin() const noexcept;
    const_iterator         cend() const noexcept;
    const_reverse_iterator crbegin() const noexcept;
    const_reverse_iterator crend() const noexcept;

    // [string.capacity], capacity
    size_type size() const noexcept;
    size_type length() const noexcept;
    size_type max_size() const noexcept;
    void resize(size_type n, charT c);
    void resize(size_type n);
    size_type capacity() const noexcept;
    void reserve(size_type res_arg = 0);
    void shrink_to_fit();
    void clear() noexcept;
    bool empty() const noexcept;

    // [string.access], element access
    const_reference operator[](size_type pos) const;
    reference       operator[](size_type pos);
    const_reference at(size_type n) const;
    reference       at(size_type n);

    const charT& front() const;
    charT&       front();
    const charT& back() const;
    charT&       back();

    // [string.modifiers], modifiers
    basic_string& operator+=(const basic_string& str);
    basic_string& operator+=(basic_string_view<charT, traits> sv);
    basic_string& operator+=(const charT* s);
    basic_string& operator+=(charT c);
    basic_string& operator+=(initializer_list<charT>);
    basic_string& append(const basic_string& str);
    basic_string& append(const basic_string& str, size_type pos,
                         size_type n = npos);
    basic_string& append(basic_string_view<charT, traits> sv);
    template<class T>
      basic_string& append(const T& t, size_type pos, size_type n = npos);
    basic_string& append(const charT* s, size_type n);
    basic_string& append(const charT* s);
    basic_string& append(size_type n, charT c);
    template<class InputIterator>
      basic_string& append(InputIterator first, InputIterator last);
    basic_string& append(initializer_list<charT>);
    void push_back(charT c);

    basic_string& assign(const basic_string& str);
    basic_string& assign(basic_string&& str)
      noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
               allocator_traits<Allocator>::is_always_equal::value);
    basic_string& assign(const basic_string& str, size_type pos,
                         size_type n = npos);
    basic_string& assign(basic_string_view<charT, traits> sv);
    template<class T>
      basic_string& assign(const T& t, size_type pos, size_type n = npos);
    basic_string& assign(const charT* s, size_type n);
    basic_string& assign(const charT* s);
    basic_string& assign(size_type n, charT c);
    template<class InputIterator>
      basic_string& assign(InputIterator first, InputIterator last);
    basic_string& assign(initializer_list<charT>);

    basic_string& insert(size_type pos, const basic_string& str);
    basic_string& insert(size_type pos1, const basic_string& str,
                         size_type pos2, size_type n = npos);
    basic_string& insert(size_type pos, basic_string_view<charT, traits> sv);
    template<class T>
      basic_string& insert(size_type pos1, const T& t,
                           size_type pos2, size_type n = npos);
    basic_string& insert(size_type pos, const charT* s, size_type n);
    basic_string& insert(size_type pos, const charT* s);
    basic_string& insert(size_type pos, size_type n, charT c);
    iterator insert(const_iterator p, charT c);
    iterator insert(const_iterator p, size_type n, charT c);
    template<class InputIterator>
      iterator insert(const_iterator p, InputIterator first, InputIterator last);
    iterator insert(const_iterator p, initializer_list<charT>);

    basic_string& erase(size_type pos = 0, size_type n = npos);
    iterator erase(const_iterator p);
    iterator erase(const_iterator first, const_iterator last);

    void pop_back();

    basic_string& replace(size_type pos1, size_type n1,
                          const basic_string& str);
    basic_string& replace(size_type pos1, size_type n1,
                          const basic_string& str,
                          size_type pos2, size_type n2 = npos);
    basic_string& replace(size_type pos1, size_type n1,
                          basic_string_view<charT, traits> sv);
    template<class T>
      basic_string& replace(size_type pos1, size_type n1, const T& t,
                            size_type pos2, size_type n2 = npos);
    basic_string& replace(size_type pos, size_type n1, const charT* s,
                          size_type n2);
    basic_string& replace(size_type pos, size_type n1, const charT* s);
    basic_string& replace(size_type pos, size_type n1, size_type n2,
                          charT c);

    basic_string& replace(const_iterator i1, const_iterator i2,
                          const basic_string& str);
    basic_string& replace(const_iterator i1, const_iterator i2,
                          basic_string_view<charT, traits> sv);
    basic_string& replace(const_iterator i1, const_iterator i2, const charT* s,
                          size_type n);
    basic_string& replace(const_iterator i1, const_iterator i2, const charT* s);
    basic_string& replace(const_iterator i1, const_iterator i2,
                          size_type n, charT c);
    template<class InputIterator>
      basic_string& replace(const_iterator i1, const_iterator i2,
                            InputIterator j1, InputIterator j2);
    basic_string& replace(const_iterator, const_iterator, initializer_list<charT>);

    size_type copy(charT* s, size_type n, size_type pos = 0) const;
    void swap(basic_string& str)
      noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
               allocator_traits<Allocator>::is_always_equal::value);

    // [string.ops], string operations
    const charT* c_str() const noexcept;
    const charT* data() const noexcept;
    charT* data() noexcept;
    operator basic_string_view<charT, traits>() const noexcept;
    allocator_type get_allocator() const noexcept;

    size_type find (basic_string_view<charT, traits> sv,
                    size_type pos = 0) const noexcept;
    size_type find (const basic_string& str, size_type pos = 0) const noexcept;
    size_type find (const charT* s, size_type pos, size_type n) const;
    size_type find (const charT* s, size_type pos = 0) const;
    size_type find (charT c, size_type pos = 0) const;
    size_type rfind(basic_string_view<charT, traits> sv,
                    size_type pos = npos) const noexcept;
    size_type rfind(const basic_string& str, size_type pos = npos) const noexcept;
    size_type rfind(const charT* s, size_type pos, size_type n) const;
    size_type rfind(const charT* s, size_type pos = npos) const;
    size_type rfind(charT c, size_type pos = npos) const;

    size_type find_first_of(basic_string_view<charT, traits> sv,
                            size_type pos = 0) const noexcept;
    size_type find_first_of(const basic_string& str,
                            size_type pos = 0) const noexcept;
    size_type find_first_of(const charT* s,
                            size_type pos, size_type n) const;
    size_type find_first_of(const charT* s, size_type pos = 0) const;
    size_type find_first_of(charT c, size_type pos = 0) const;
    size_type find_last_of (basic_string_view<charT, traits> sv,
                            size_type pos = npos) const noexcept;
    size_type find_last_of (const basic_string& str,
                            size_type pos = npos) const noexcept;
    size_type find_last_of (const charT* s,
                            size_type pos, size_type n) const;
    size_type find_last_of (const charT* s, size_type pos = npos) const;
    size_type find_last_of (charT c, size_type pos = npos) const;

    size_type find_first_not_of(basic_string_view<charT, traits> sv,
                                size_type pos = 0) const noexcept;
    size_type find_first_not_of(const basic_string& str,
                                size_type pos = 0) const noexcept;
    size_type find_first_not_of(const charT* s, size_type pos,
                                size_type n) const;
    size_type find_first_not_of(const charT* s, size_type pos = 0) const;
    size_type find_first_not_of(charT c, size_type pos = 0) const;
    size_type find_last_not_of (basic_string_view<charT, traits> sv,
                                size_type pos = npos) const noexcept;
    size_type find_last_not_of (const basic_string& str,
                                size_type pos = npos) const noexcept;
    size_type find_last_not_of (const charT* s, size_type pos,
                                size_type n) const;
    size_type find_last_not_of (const charT* s,
                                size_type pos = npos) const;
    size_type find_last_not_of (charT c, size_type pos = npos) const;

    basic_string substr(size_type pos = 0, size_type n = npos) const;
    int compare(basic_string_view<charT, traits> sv) const noexcept;
    int compare(size_type pos1, size_type n1,
                basic_string_view<charT, traits> sv) const;
    template<class T>
      int compare(size_type pos1, size_type n1, const T& t,
                  size_type pos2, size_type n2 = npos) const;
    int compare(const basic_string& str) const noexcept;
    int compare(size_type pos1, size_type n1,
                const basic_string& str) const;
    int compare(size_type pos1, size_type n1,
                const basic_string& str,
                size_type pos2, size_type n2 = npos) const;
    int compare(const charT* s) const;
    int compare(size_type pos1, size_type n1,
                const charT* s) const;
    int compare(size_type pos1, size_type n1,
                const charT* s, size_type n2) const;
  };

  template<class InputIterator,
           class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
    basic_string(InputIterator, InputIterator, Allocator = Allocator())
      -> basic_string<typename iterator_traits<InputIterator>::value_type,
                      char_traits<typename iterator_traits<InputIterator>::value_type>,
                      Allocator>;
}
225)

Allocator​::​value_­type должен называть тот же тип, что и charT ([string.require]).

24.3.2.1 basic_­string general requirements [string.require]

1
#

Если какая-либо операция вызовет size() превышение max_­size(), эта операция вызовет объект исключения типа length_­error.

2
#

Если какая-либо функция-член или оператор basic_­string выдает исключение, эта функция или оператор не должны иметь никакого другого эффекта.

3
#

В каждой специализации basic_­string<charT, traits, Allocator>тип allocator_­traits<Allocator>​::​value_­type должен называть тот же тип, что и charT. Каждый объект типа basic_­string<charT, traits, Allocator> должен использовать объект типа Allocator для выделения и освобождения памяти для содержащихся charT объектов по мере необходимости. Используемый Allocator объект должен быть получен, как описано в [container.requirements.general]. В каждой специализации basic_­string<charT, traits, Allocator>тип traits должен удовлетворять требованиям к характеристикам символов ([char.traits]), и тип traits​::​char_­type должен называть тот же тип, что и charT.

4
#

Ссылки, указатели и итераторы, относящиеся к элементам basic_­string последовательности, могут быть признаны недействительными при следующих применениях этого basic_­string объекта:

  • (4.1)

    в качестве аргумента любой стандартной библиотечной функции, принимающейbasic_­string в качестве аргумента ссылку на неконстантный .226

  • (4.2)

    Вызов неконстантная функций - членов, за исключением operator[], at, data, front, back, begin, rbegin, end, и rend.

226)

Например, в качестве аргумента для функций swap(), не являющихся членамиoperator>>(), и getline(), или в качестве аргумента для basic_­string​::​swap().

24.3.2.2 basic_­string constructors and assignment operators [string.cons]

explicit basic_string(const Allocator& a) noexcept;

1
#

Effects: Создает объект класса basic_­string. Постусловия этой функции указаны в таблице 55.

Таблица 55 - basic_­string(const Allocator&) эффекты
ЭлементЦенить
data() ненулевой указатель, который можно копировать и к нему можно добавить 0
size() 0
capacity() неуказанное значение

basic_string(const basic_string& str); basic_string(basic_string&& str) noexcept;

2
#

Effects: Создает объект класса, basic_­string как указано в Табл 56. Во второй форме str остается в допустимом состоянии с неопределенным значением.

Таблица 56 - basic_­string(const basic_­string&) эффекты
ЭлементЦенить
data() указывает на первый элемент выделенной копии массива, на первый элемент которого указывает str.data()
size() str.size()
capacity() значение, по крайней мере, такое большое, как size()

basic_string(const basic_string& str, size_type pos, const Allocator& a = Allocator());

3
#

Throws: out_­of_­range если pos > str.size().

4
#

Effects: Создает объект класса basic_­string и определяет эффективную длину rlen начального строкового значения str.size() - pos, как указано в Табл 57.

basic_string(const basic_string& str, size_type pos, size_type n, const Allocator& a = Allocator());

5
#

Throws: out_­of_­range если pos > str.size().

6
#

Effects: Создает объект класса basic_­string и определяет эффективную длину rlen начального строкового значения как меньшее из n и str.size() - pos, как указано в таблице 57.

Таблица 57 - и эффекты basic_­string(const basic_­string&, size_­type, const Allocator&)
basic_­string(const basic_­string&, size_­type, size_­type, const Allocator&)
ЭлементЦенить
data() указывает на первый элемент выделенной копии rlen последовательных элементов строки, управляемой str начиная с позиции pos
size() rlen
capacity() значение, по крайней мере, такое большое, как size()

template<class T> basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());

7
#

Effects: Создает переменную, svкак если бы by, basic_­string_­view<charT, traits> sv = t; а затем ведет себя так же, как: 

basic_string(sv.substr(pos, n), a);
8
#

Remarks: Этот конструктор не должен участвовать в разрешении перегрузки , если is_­convertible_­v<const T&, basic_­string_­view<charT, traits>> не true.

explicit basic_string(basic_string_view<charT, traits> sv, const Allocator& a = Allocator());

9
#

Effects: То же, что и basic_­string(sv.data(), sv.size(), a).

basic_string(const charT* s, size_type n, const Allocator& a = Allocator());

10
#

Requires: s указывает на массив, состоящий как минимум из n элементов charT.

11
#

Effects: Создает объект класса basic_­string и определяет его начальное строковое значение из массива charT длины n , первый элемент которого обозначен s, как указано в таблице 58.

Таблица 58 - basic_­string(const charT*, size_­type, const Allocator&) эффекты
ЭлементЦенить
data() указывает на первый элемент выделенной копии массива, на первый элемент которого указывает s
size() n
capacity() значение, по крайней мере, такое большое, как size()

basic_string(const charT* s, const Allocator& a = Allocator());

12
#

Requires: s указывает на массив, состоящий как минимум из traits​::​length(s) + 1 элементов charT.

13
#

Effects: Создает объект класса basic_­string и определяет его начальное строковое значение из массива charT длины traits​::​length(s) , первый элемент которого обозначен s, как указано в таблице 59.

Таблица 59 - basic_­string(const charT*, const Allocator&) эффекты
ЭлементЦенить
data() указывает на первый элемент выделенной копии массива, на первый элемент которого указывает s
size() traits​::​length(s)
capacity() значение, по крайней мере, такое большое, как size()

basic_string(size_type n, charT c, const Allocator& a = Allocator());

14
#

Requires: n < npos.

15
#

Effects: Создает объект класса basic_­string и определяет его начальное строковое значение, повторяя объект типа char c для всех n элементов, как указано в таблице 60.

Таблица 60 - basic_­string(size_­t, charT, const Allocator&) эффекты
ЭлементЦенить
data() указывает на первый элемент выделенного массива n элементов, каждый из которых хранит начальное значение c
size() n
capacity() значение, по крайней мере, такое большое, как size()

template<class InputIterator> basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());

16
#

Effects: Если InputIterator это целочисленный тип, эквивалентный: 

basic_string(static_cast<size_type>(begin), static_cast<value_type>(end), a);

В противном случае создает строку из значений в диапазоне [begin, end), как указано в таблице требований к последовательности (см. [sequence.reqmts]).

basic_string(initializer_list<charT> il, const Allocator& a = Allocator());

17
#

Effects: То же, что и basic_­string(il.begin(), il.end(), a).

basic_string(const basic_string& str, const Allocator& alloc); basic_string(basic_string&& str, const Allocator& alloc);

18
#

Effects: Создает объект класса, basic_­string как указано в Табл 61. Сохраненный распределитель построен из alloc. Во второй форме str остается в допустимом состоянии с неопределенным значением.

Таблица 61 - и эффекты basic_­string(const basic_­string&, const Allocator&)
basic_­string(basic_­string&&, const Allocator&)
ЭлементЦенить
data() указывает на первый элемент выделенной копии массива, на первый элемент которого указывает исходное значение str.data().
size() первоначальная стоимость str.size()
capacity() значение, по крайней мере, такое большое, как size()
get_­allocator() alloc
19
#

Throws: Вторая форма ничего не бросает, если alloc == str.get_­allocator().

template<class InputIterator, class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>> basic_string(InputIterator, InputIterator, Allocator = Allocator()) -> basic_string<typename iterator_traits<InputIterator>::value_type, char_traits<typename iterator_traits<InputIterator>::value_type>, Allocator>;

20
#

Remarks: Не должен участвовать в разрешении перегрузки, если InputIterator это тип, который не квалифицируется как итератор ввода, или если Allocator это тип, который не квалифицируется как распределитель ([container.requirements.general]).

basic_string& operator=(const basic_string& str);

21
#

Effects: Если *this и str являются разными объектами, изменяется, *this как показано в Табл 62.

22
#

Если *this и str являются одним и тем же объектом, член не имеет никакого эффекта.

23
#

Returns: *this.

Таблица 62 - operator=(const basic_­string&) эффекты
ЭлементЦенить
data() указывает на первый элемент выделенной копии массива, на первый элемент которого указывает str.data()
size() str.size()
capacity() значение, по крайней мере, такое большое, как size()

basic_string& operator=(basic_string&& str) noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value || allocator_traits<Allocator>::is_always_equal::value);

24
#

Effects: Перемещение присваивается как a sequence container, за исключением того, что итераторы, указатели и ссылки могут быть недействительными.

25
#

Returns: *this.

basic_string& operator=(basic_string_view<charT, traits> sv);

26
#

Effects: Эквивалентно: return assign(sv);

basic_string& operator=(const charT* s);

27
#

Returns: *this = basic_­string(s).

28
#

Remarks: Использует traits​::​length().

basic_string& operator=(charT c);

29
#

Returns: *this = basic_­string(1, c).

basic_string& operator=(initializer_list<charT> il);

30
#

Effects: Как будто по: *this = basic_­string(il);

31
#

Returns: *this.

24.3.2.3 basic_­string iterator support [string.iterators]

iterator begin() noexcept; const_iterator begin() const noexcept; const_iterator cbegin() const noexcept;

1
#

Returns: Итератор, относящийся к первому символу в строке.

iterator end() noexcept; const_iterator end() const noexcept; const_iterator cend() const noexcept;

2
#

Returns: Итератор, являющийся последним значением.

reverse_iterator rbegin() noexcept; const_reverse_iterator rbegin() const noexcept; const_reverse_iterator crbegin() const noexcept;

3
#

Returns: Итератор, семантически эквивалентный reverse_­iterator(end()).

reverse_iterator rend() noexcept; const_reverse_iterator rend() const noexcept; const_reverse_iterator crend() const noexcept;

4
#

Returns: Итератор, семантически эквивалентный reverse_­iterator(begin()).

24.3.2.4 basic_­string capacity [string.capacity]

size_type size() const noexcept;

1
#

Returns: Подсчет количества символьных объектов, находящихся в данный момент в строке.

2
#

Complexity: Постоянное время.

size_type length() const noexcept;

3
#

Returns: size().

size_type max_size() const noexcept;

4
#

Returns: Максимально возможное количество символьных объектов, которые могут храниться в basic_­string.

5
#

Complexity: Постоянное время.

void resize(size_type n, charT c);

6
#

Throws: length_­error если n > max_­size().

7
#

Effects: Изменяет длину строки, обозначенной *this следующим образом:

  • (7.1)

    Если n <= size()функция заменяет строку, обозначенную знаком, *this строкой длины n , элементы которой являются копией начальных элементов исходной строки, обозначенной *this.

  • (7.2)

    Если n > size(), функция заменяет строку, обозначенную *this с помощью, строкой длины n , первые size() элементы которой являются копией исходной строки, обозначенной с помощью *this, а остальные элементы которой инициализируются c.

void resize(size_type n);

8
#

Effects: Как будто мимо resize(n, charT()).

size_type capacity() const noexcept;

9
#

Returns: Размер выделенного хранилища в строке.

void reserve(size_type res_arg=0);

10
#

Функция-член reserve() - это директива, информирующая basic_­string объект о запланированном изменении размера, чтобы он мог соответствующим образом управлять распределением хранилища.

11
#

Effects: После тогоreserve(), capacity() больше или равен аргумент reserve. [  Note: Вызов reserve() с res_­arg аргументом, меньшим чем capacity() , по сути, является необязательным запросом на сжатие. Обращение с помощью res_­arg <= size() по сути является необязательным запросом на усадку по размеру. ] — end note 

12
#

Throws: length_­error если res_­arg > max_­size().227

void shrink_to_fit();

13
#

Effects: shrink_­to_­fit является необязательным запросом для сокращения capacity() до size(). [  Note: Запрос не является обязывающим, чтобы дать свободу для оптимизации, зависящей от реализации. ] Он не увеличивается , но может уменьшаться , вызывая перераспределение.  — end note  capacity() capacity()

14
#

Complexity: Линейный по размеру последовательности.

15
#

Remarks: Перераспределение делает недействительными все ссылки, указатели и итераторы, относящиеся к элементам в последовательности, а также к итератору, прошедшему конец. Если перераспределения не происходит, они остаются в силе.

void clear() noexcept;

16
#

Effects: Ведет себя так, как будто функция вызывает:

erase(begin(), end());

bool empty() const noexcept;

17
#

Returns: size() == 0.

227)

reserve() использования, allocator_­traits<Allocator>​::​allocate() которые могут вызвать соответствующее исключение.

24.3.2.5 basic_­string element access [string.access]

const_reference operator[](size_type pos) const; reference operator[](size_type pos);
1
#

Requires: pos <= size().

2
#

Returns: *(begin() + pos) если pos < size(). В противном случае возвращает ссылку на объект типа charT со значением charT(), где изменение объекта на любое значение, кроме charT() приводит к неопределенному поведению.

3
#

Throws: Ничего такого.

4
#

Complexity: Постоянное время.

const_reference at(size_type pos) const; reference at(size_type pos);
5
#

Throws: out_­of_­range если pos >= size().

6
#

Returns: operator[](pos).

const charT& front() const; charT& front();
7
#

Requires: !empty().

8
#

Effects: Эквивалентно: return operator[](0);

const charT& back() const; charT& back();
9
#

Requires: !empty().

10
#

Effects: Эквивалентно: return operator[](size() - 1);

24.3.2.6 basic_­string modifiers [string.modifiers]

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

basic_string& operator+=(const basic_string& str);

1
#

Effects: Звонки append(str).

2
#

Returns: *this.

basic_string& operator+=(basic_string_view<charT, traits> sv);

3
#

Effects: Звонки append(sv).

4
#

Returns: *this.

basic_string& operator+=(const charT* s);

5
#

Effects: Звонки append(s).

6
#

Returns: *this.

basic_string& operator+=(charT c);

7
#

Effects: Звонки push_­back(c);

8
#

Returns: *this.

basic_string& operator+=(initializer_list<charT> il);

9
#

Effects: Звонки append(il).

10
#

Returns: *this.

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

basic_string& append(const basic_string& str);

1
#

Effects: Звонки 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 если pos > str.size().

4
#

Effects: Определяет эффективную длину rlen добавляемой строки как меньшее из вызовов n и str.size() - pos и append(str.data() + pos, rlen).

5
#

Returns: *this.

basic_string& append(basic_string_view<charT, traits> sv);

6
#

Effects: Эквивалентно: return append(sv.data(), sv.size());

template<class T> basic_string& append(const T& t, size_type pos, size_type n = npos);

7
#

Throws: out_­of_­range если pos > sv.size().

8
#

Effects: Создает переменную sv, как будто by basic_­string_­view<charT, traits> sv = t. Определяет эффективную длину rlen добавляемой строки как меньшее из вызовов n и sv.size() - posи append(sv.data() + pos, rlen).

9
#

Remarks: Эта функция не будет участвовать в разрешении перегрузки , если is_­convertible_­v<const T&, basic_­string_­view<charT, traits>> не true и is_­convertible_­v<const T&, const charT*> является false.

10
#

Returns: *this.

basic_string& append(const charT* s, size_type n);

11
#

Requires: s указывает на массив, состоящий как минимум из n элементов charT.

12
#

Throws: length_­error если size() + n > max_­size().

13
#

Effects: Функция заменяет строку, которой управляет, *this строкой длины size() + n , первые size() элементы которой являются копией исходной строки, которой управляет, *this а остальные элементы - копией начальных n элементов s.

14
#

Returns: *this.

basic_string& append(const charT* s);

15
#

Requires: s указывает на массив, состоящий как минимум из traits​::​length(s) + 1 элементов charT.

16
#

Effects: Звонки append(s, traits​::​length(s)).

17
#

Returns: *this.

basic_string& append(size_type n, charT c);

18
#

Effects: Эквивалентно append(basic_­string(n, c)).

19
#

Returns: *this.

template<class InputIterator> basic_string& append(InputIterator first, InputIterator last);

20
#

Requires: [first, last) допустимый диапазон.

21
#

Effects: Эквивалентно append(basic_­string(first, last, get_­allocator())).

22
#

Returns: *this.

basic_string& append(initializer_list<charT> il);

23
#

Effects: Звонки append(il.begin(), il.size()).

24
#

Returns: *this.

void push_back(charT c);

25
#

Effects: Эквивалентно append(static_­cast<size_­type>(1), c).

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

basic_string& assign(const basic_string& str);

1
#

Effects: Эквивалентно *this = str.

2
#

Returns: *this.

basic_string& assign(basic_string&& str) noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value || allocator_traits<Allocator>::is_always_equal::value);

3
#

Effects: Эквивалентно *this = std​::​move(str).

4
#

Returns: *this.

basic_string& assign(const basic_string& str, size_type pos, size_type n = npos);

5
#

Throws: out_­of_­range если pos > str.size().

6
#

Effects: Определяет эффективную длину rlen строки, которая назначается как меньшее из вызовов n и str.size() - pos и assign(str.data() + pos, rlen).

7
#

Returns: *this.

basic_string& assign(basic_string_view<charT, traits> sv);

8
#

Effects: Эквивалентно: return assign(sv.data(), sv.size());

template<class T> basic_string& assign(const T& t, size_type pos, size_type n = npos);

9
#

Throws: out_­of_­range если pos > sv.size().

10
#

Effects: Создает переменную sv, как будто by basic_­string_­view<charT, traits> sv = t. Определяет эффективную длину rlen строки, которая назначается как меньшее из вызовов n и sv.size() - posи assign(sv.data() + pos, rlen).

11
#

Remarks: Эта функция не будет участвовать в разрешении перегрузки , если is_­convertible_­v<const T&, basic_­string_­view<charT, traits>> не true и is_­convertible_­v<const T&, const charT*> является false.

12
#

Returns: *this.

basic_string& assign(const charT* s, size_type n);

13
#

Requires: s указывает на массив, состоящий как минимум из n элементов charT.

14
#

Throws: length_­error если n > max_­size().

15
#

Effects: Заменяет строку, управляемую *this с помощью, строкой длины n , элементы которой являются копией тех, на которые указывает s.

16
#

Returns: *this.

basic_string& assign(const charT* s);

17
#

Requires: s указывает на массив, состоящий как минимум из traits​::​length(s) + 1 элементов charT.

18
#

Effects: Звонки assign(s, traits​::​length(s)).

19
#

Returns: *this.

basic_string& assign(initializer_list<charT> il);

20
#

Effects: Звонки assign(il.begin(), il.size()).

21
#

*this.

basic_string& assign(size_type n, charT c);

22
#

Effects: Эквивалентно assign(basic_­string(n, c)).

23
#

Returns: *this.

template<class InputIterator> basic_string& assign(InputIterator first, InputIterator last);

24
#

Effects: Эквивалентно assign(basic_­string(first, last, get_­allocator())).

25
#

Returns: *this.

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

basic_string& insert(size_type pos, const basic_string& str);

1
#

Effects: Эквивалентно: 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 если pos1 > size() или pos2 > str.size().

3
#

Effects: Определяет эффективную длину rlen строки для вставки в качестве меньшего из вызовов n и str.size() - pos2 и insert(pos1, str.data() + pos2, rlen).

4
#

Returns: *this.

basic_string& insert(size_type pos, basic_string_view<charT, traits> sv);

5
#

Effects: Эквивалентно: return insert(pos, sv.data(), sv.size());

template<class T> basic_string& insert(size_type pos1, const T& t, size_type pos2, size_type n = npos);

6
#

Throws: out_­of_­range если pos1 > size() или pos2 > sv.size().

7
#

Effects: Создает переменную sv, как будто by basic_­string_­view<charT, traits> sv = t. Определяет эффективную длину rlen строки, которая назначается как меньшее из вызовов n и sv.size() - pos2и insert(pos1, sv.data() + pos2, rlen).

8
#

Remarks: Эта функция не будет участвовать в разрешении перегрузки , если is_­convertible_­v<const T&, basic_­string_­view<charT, traits>> не true и is_­convertible_­v<const T&, const charT*> является false.

9
#

Returns: *this.

basic_string& insert(size_type pos, const charT* s, size_type n);

10
#

Requires: s указывает на массив, состоящий как минимум из n элементов charT.

11
#

Throws: out_­of_­range если pos > size() или length_­error если size() + n > max_­size().

12
#

Effects: Заменяет строку, управляемую *this строкой длины size() + n , первые pos элементы которой являются копией начальных элементов исходной строки, которой управляет, *this и чьи следующие n элементы являются копией элементов в, s а остальные элементы являются копией остальных элементов исходная строка, управляемая *this.

13
#

Returns: *this.

basic_string& insert(size_type pos, const charT* s);

14
#

Requires: s указывает на массив, состоящий как минимум из traits​::​length(s) + 1 элементов charT.

15
#

Effects: Эквивалентно: return insert(pos, s, traits​::​length(s));

basic_string& insert(size_type pos, size_type n, charT c);

16
#

Effects: Эквивалентно insert(pos, basic_­string(n, c)).

17
#

Returns: *this.

iterator insert(const_iterator p, charT c);

18
#

Requires: p является допустимым итератором на *this.

19
#

Effects: Вставляет копию c перед символом, на который ссылается p.

20
#

Returns: Итератор, который ссылается на копию вставленного символа.

iterator insert(const_iterator p, size_type n, charT c);

21
#

Requires: p является допустимым итератором на *this.

22
#

Effects: Вставляет n копии c перед символом, на который ссылается p.

23
#

Returns: Итератор, который ссылается на копию первого вставленного символа, или p если n == 0.

template<class InputIterator> iterator insert(const_iterator p, InputIterator first, InputIterator last);

24
#

Requires: p является допустимым итератором на *this. [first, last) допустимый диапазон.

25
#

Effects: Эквивалентно insert(p - begin(), basic_­string(first, last, get_­allocator())).

26
#

Returns: Итератор, который ссылается на копию первого вставленного символа, или p если first == last.

iterator insert(const_iterator p, initializer_list<charT> il);

27
#

Effects: Как будто мимо insert(p, il.begin(), il.end()).

28
#

Returns: Итератор, который ссылается на копию первого вставленного символа или p если i1 он пуст.

24.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 если pos > size().

2
#

Effects: Определяет эффективную длину xlen удаляемой строки как меньшее из значений n и size() - pos.

3
#

Затем функция заменяет строку, управляемую *this с помощью строки длины size() - xlen , первые pos элементы которой являются копией начальных элементов исходной строки, которой управляет *this, а остальные элементы которой являются копией элементов исходной строки, управляемой *this начиная с позиции pos + xlen.

4
#

Returns: *this.

iterator erase(const_iterator p);

5
#

Throws: Ничего такого.

6
#

Effects: Удаляет символ, на который ссылается p.

7
#

Returns: Итератор, который указывает на элемент, следующий непосредственно за p стираемым элементом. Если такого элемента не существует, end() возвращается.

iterator erase(const_iterator first, const_iterator last);

8
#

Requires: first и last являются действительными итераторами *this, определяющими диапазон [first, last).

9
#

Throws: Ничего такого.

10
#

Effects: Удаляет символы в диапазоне [first, last).

11
#

Returns: Итератор, который указывает на элемент, на который указывает до last удаления других элементов. Если такого элемента не существует, end() возвращается.

void pop_back();

12
#

Requires: !empty().

13
#

Throws: Ничего такого.

14
#

Effects: Эквивалентно erase(size() - 1, 1).

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

basic_string& replace(size_type pos1, size_type n1, const basic_string& str);

1
#

Effects: Эквивалентно: 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 если pos1 > size() или pos2 > str.size().

3
#

Effects: Определяет эффективную длину rlen вставляемой строки как меньшее из вызовов n2 и str.size() - pos2 и replace(pos1, n1, str.data() + pos2, rlen).

4
#

Returns: *this.

basic_string& replace(size_type pos1, size_type n1, basic_string_view<charT, traits> sv);

5
#

Effects: Эквивалентно: return replace(pos1, n1, sv.data(), sv.size());

template<class T> basic_string& replace(size_type pos1, size_type n1, const T& t, size_type pos2, size_type n2 = npos);

6
#

Throws: out_­of_­range если pos1 > size() или pos2 > sv.size().

7
#

Effects: Создает переменную sv, как будто by basic_­string_­view<charT, traits> sv = t. Определяет эффективную длину rlen вставляемой строки как меньшее из вызовов n2 и sv.size() - pos2и replace(pos1, n1, sv.data() + pos2, rlen).

8
#

Remarks: Эта функция не будет участвовать в разрешении перегрузки , если is_­convertible_­v<const T&, basic_­string_­view<charT, traits>> не true и is_­convertible_­v<const T&, const charT*> является false.

9
#

Returns: *this.

basic_string& replace(size_type pos1, size_type n1, const charT* s, size_type n2);

10
#

Requires: s указывает на массив, состоящий как минимум из n2 элементов charT.

11
#

Throws: out_­of_­range если pos1 > size() или length_­error если длина результирующей строки превысит max_­size() (см. ниже).

12
#

Effects: Определяет эффективную длину xlen удаляемой строки как меньшее из значений n1 и size() - pos1. Если size() - xlen >= max_­size() - n2 кидает length_­error. В противном случае функция заменяет строку, управляемую символом *,this строкой длины size() - xlen + n2 , первые pos1 элементы которой являются копией начальных элементов исходной строки *this, которой управляет , чьи следующие n2 элементы являются копией начальных n2 элементов s, а остальные элементы - копия элементов исходной строки, управляемая *this начиная с позиции pos + xlen.

13
#

Returns: *this.

basic_string& replace(size_type pos, size_type n, const charT* s);

14
#

Requires: s указывает на массив, состоящий как минимум из traits​::​length(s) + 1 элементов charT.

15
#

Effects: Эквивалентно: return replace(pos, n, s, traits​::​length(s));

basic_string& replace(size_type pos1, size_type n1, size_type n2, charT c);

16
#

Effects: Эквивалентно replace(pos1, n1, basic_­string(n2, c)).

17
#

Returns: *this.

basic_string& replace(const_iterator i1, const_iterator i2, const basic_string& str);

18
#

Requires: [begin(), i1) и [i1, i2) допустимые диапазоны.

19
#

Effects: Звонки replace(i1 - begin(), i2 - i1, str).

20
#

Returns: *this.

basic_string& replace(const_iterator i1, const_iterator i2, basic_string_view<charT, traits> sv);

21
#

Requires: [begin(), i1) и [i1, i2) допустимые диапазоны.

22
#

Effects: Звонки replace(i1 - begin(), i2 - i1, sv).

23
#

Returns: *this.

basic_string& replace(const_iterator i1, const_iterator i2, const charT* s, size_type n);

24
#

Requires: [begin(), i1) и [i1, i2) являются допустимыми диапазонами и s указывают на массив, состоящий как минимум из n элементов charT.

25
#

Effects: Звонки replace(i1 - begin(), i2 - i1, s, n).

26
#

Returns: *this.

basic_string& replace(const_iterator i1, const_iterator i2, const charT* s);

27
#

Requires: [begin(), i1) и [i1, i2) являются допустимыми диапазонами и s указывают на массив, состоящий как минимум из traits​::​​length(s) + 1 элементов charT.

28
#

Effects: Звонки replace(i1 - begin(), i2 - i1, s, traits​::​length(s)).

29
#

Returns: *this.

basic_string& replace(const_iterator i1, const_iterator i2, size_type n, charT c);

30
#

Requires: [begin(), i1) и [i1, i2) допустимые диапазоны.

31
#

Effects: Звонки replace(i1 - begin(), i2 - i1, basic_­string(n, c)).

32
#

Returns: *this.

template<class InputIterator> basic_string& replace(const_iterator i1, const_iterator i2, InputIterator j1, InputIterator j2);

33
#

Requires: [begin(), i1), [i1, i2) и [j1, j2) допустимые диапазоны.

34
#

Effects: Звонки replace(i1 - begin(), i2 - i1, basic_­string(j1, j2, get_­allocator())).

35
#

Returns: *this.

basic_string& replace(const_iterator i1, const_iterator i2, initializer_list<charT> il);

36
#

Requires: [begin(), i1) и [i1, i2) допустимые диапазоны.

37
#

Effects: Звонки replace(i1 - begin(), i2 - i1, il.begin(), il.size()).

38
#

Returns: *this.

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

size_type copy(charT* s, size_type n, size_type pos = 0) const;

1
#

Позвольте rlen быть меньшим из n и size() - pos.

2
#

Throws: out_­of_­range если pos > size().

3
#

Requires: [s, s + rlen) допустимый диапазон.

4
#

Effects: Эквивалент: traits​::​copy(s, data() + pos, rlen). [  Note: Это не заканчивается s нулевым объектом. ]  — end note 

5
#

Returns: rlen.

24.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
#

Postconditions: *this содержит ту же последовательность символов, которая была в s, s содержит ту же последовательность символов, что была в *this.

2
#

Throws: Ничего такого.

3
#

Complexity: Постоянное время.

24.3.2.7 basic_­string string operations [string.ops]

24.3.2.7.1 basic_­string accessors [string.accessors]

const charT* c_str() const noexcept; const charT* data() const noexcept;

1
#

Returns: Указатель p такой, что p + i == &operator[](i) для каждого i в [0, size()].

2
#

Complexity: Постоянное время.

3
#

Requires: Программа не должна изменять никаких значений, хранящихся в массиве символов.

charT* data() noexcept;

4
#

Returns: Указатель p такой, что p + i == &operator[](i) для каждого i в [0, size()].

5
#

Complexity: Постоянное время.

6
#

Requires: Программа не должна изменять значение, хранящееся в p + size().

operator basic_string_view<charT, traits>() const noexcept;

7
#

Effects: Эквивалентно: return basic_­string_­view<charT, traits>(data(), size());

allocator_type get_allocator() const noexcept;

8
#

Returns: Копия Allocator объекта, используемого для создания строки, или, если этот распределитель был заменен, копия самой последней замены.

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

size_type find(basic_string_view<charT, traits> sv, size_type pos = 0) const noexcept;

1
#

Effects: Определяет xpos, если возможно, самое низкое положение , при котором выполняются оба следующих условия:

  • (1.1)

    pos <= xpos и xpos + sv.size() <= size();

  • (1.2)

    traits​::​eq(at(xpos + I), sv.at(I)) для всех элементов I данных, на которые ссылается sv.

2
#

Returns: xpos если функция может определить такое значение для xpos. В противном случае возвращается npos.

size_type find(const basic_string& str, size_type pos = 0) const noexcept;

3
#

Effects: Эквивалентно: return find(basic_­string_­view<charT, traits>(str), pos);

size_type find(const charT* s, size_type pos, size_type n) const;

4
#

Returns: find(basic_­string_­view<charT, traits>(s, n), pos).

size_type find(const charT* s, size_type pos = 0) const;

5
#

Requires: s указывает на массив, состоящий как минимум из traits​::​length(s) + 1 элементов charT.

6
#

Returns: find(basic_­string_­view<charT, traits>(s), pos).

size_type find(charT c, size_type pos = 0) const;

7
#

Returns: find(basic_­string(1, c), pos).

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

size_type rfind(basic_string_view<charT, traits> sv, size_type pos = npos) const noexcept;

1
#

Effects: Определяет xpos, если возможно, наивысшее положение , при котором выполняются оба следующих условия:

  • (1.1)

    xpos <= pos и xpos + sv.size() <= size();

  • (1.2)

    traits​::​eq(at(xpos + I), sv.at(I)) для всех элементов I данных, на которые ссылается sv.

2
#

Returns: xpos если функция может определить такое значение для xpos. В противном случае возвращается npos.

size_type rfind(const basic_string& str, size_type pos = npos) const noexcept;

3
#

Effects: Эквивалентно: return rfind(basic_­string_­view<charT, traits>(str), pos);

size_type rfind(const charT* s, size_type pos, size_type n) const;

4
#

Returns: rfind(basic_­string_­view<charT, traits>(s, n), pos).

size_type rfind(const charT* s, size_type pos = npos) const;

5
#

Requires: s указывает на массив, состоящий как минимум из traits​::​length(s) + 1 элементов charT.

6
#

Returns: rfind(basic_­string_­view<charT, traits>(s), pos).

size_type rfind(charT c, size_type pos = npos) const;

7
#

Returns: rfind(basic_­string(1, c), pos).

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

size_type find_first_of(basic_string_view<charT, traits> sv, size_type pos = 0) const noexcept;

1
#

Effects: Определяет xpos, если возможно, самое низкое положение , при котором выполняются оба следующих условия:

  • (1.1)

    pos <= xpos и xpos < size();

  • (1.2)

    traits​::​eq(at(xpos), sv.at(I)) для некоторого элемента I данных, на который ссылается sv.

2
#

Returns: xpos если функция может определить такое значение для xpos. В противном случае возвращается npos.

size_type find_first_of(const basic_string& str, size_type pos = 0) const noexcept;

3
#

Effects: Эквивалентно: 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;

4
#

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;

5
#

Requires: s указывает на массив, состоящий как минимум из traits​::​length(s) + 1 элементов charT.

6
#

Returns: find_­first_­of(basic_­string_­view<charT, traits>(s), pos).

size_type find_first_of(charT c, size_type pos = 0) const;

7
#

Returns: find_­first_­of(basic_­string(1, c), pos).

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

size_type find_last_of(basic_string_view<charT, traits> sv, size_type pos = npos) const noexcept;

1
#

Effects: Определяет xpos, если возможно, наивысшее положение , при котором выполняются оба следующих условия:

  • (1.1)

    xpos <= pos и xpos < size();

  • (1.2)

    traits​::​eq(at(xpos), sv.at(I)) для некоторого элемента I данных, на который ссылается sv.

2
#

Returns: xpos если функция может определить такое значение для xpos. В противном случае возвращается npos.

size_type find_last_of(const basic_string& str, size_type pos = npos) const noexcept;

3
#

Effects: Эквивалентно: 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;

4
#

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;

5
#

Requires: s указывает на массив, состоящий как минимум из traits​::​length(s) + 1 элементов charT.

6
#

Returns: find_­last_­of(basic_­string_­view<charT, traits>(s), pos).

size_type find_last_of(charT c, size_type pos = npos) const;

7
#

Returns: find_­last_­of(basic_­string(1, c), pos).

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

size_type find_first_not_of(basic_string_view<charT, traits> sv, size_type pos = 0) const noexcept;

1
#

Effects: Определяет xpos, если возможно, самое низкое положение , при котором выполняются оба следующих условия:

  • (1.1)

    pos <= xpos и xpos < size();

  • (1.2)

    traits​::​eq(at(xpos), sv.at(I)) для ни одного элемента I данных, на который ссылается sv.

2
#

Returns: xpos если функция может определить такое значение для xpos. В противном случае возвращается npos.

size_type find_first_not_of(const basic_string& str, size_type pos = 0) const noexcept;

3
#

Effects: Эквивалентно: 

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;

4
#

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;

5
#

Requires: s указывает на массив, состоящий как минимум из traits​::​length(s) + 1 элементов charT.

6
#

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;

7
#

Returns: find_­first_­not_­of(basic_­string(1, c), pos).

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

size_type find_last_not_of(basic_string_view<charT, traits> sv, size_type pos = npos) const noexcept;

1
#

Effects: Определяет xpos, если возможно, наивысшее положение , при котором выполняются оба следующих условия:

  • (1.1)

    xpos <= pos и xpos < size();

  • (1.2)

    traits​::​eq(at(xpos), sv.at(I)) для ни одного элемента I данных, на который ссылается sv.

2
#

Returns: xpos если функция может определить такое значение для xpos. В противном случае возвращается npos.

size_type find_last_not_of(const basic_string& str, size_type pos = npos) const noexcept;

3
#

Effects: Эквивалентно: 

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;

4
#

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;

5
#

Requires: s указывает на массив, состоящий как минимум из traits​::​length(s) + 1 элементов charT.

6
#

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;

7
#

Returns: find_­last_­not_­of(basic_­string(1, c), pos).

24.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 если pos > size().

2
#

Effects: Определяет эффективную длину rlen копируемой строки как меньшее из значений n и size() - pos.

3
#

Returns: basic_­string(data()+pos, rlen).

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

int compare(basic_string_view<charT, traits> sv) const noexcept;

1
#

Effects: Определяет эффективную длину rlen строк для сравнения как меньшее из значений size() и sv.size(). Затем функция сравнивает две строки, вызывая traits​::​compare(data(), sv.data(), rlen).

2
#

Returns: Ненулевой результат, если результат сравнения отличен от нуля. В противном случае возвращает значение, указанное в таблице 63.

Таблица 63 - compare() результаты
СостояниеВозвращаемое значение
size() <  sv.size() < 0
size() == sv.size()  0
size() >  sv.size() > 0

int compare(size_type pos1, size_type n1, basic_string_view<charT, traits> sv) const;

3
#

Effects: Эквивалентно: 

return basic_string_view<charT, traits>(data(), size()).substr(pos1, n1).compare(sv);

template<class T> int compare(size_type pos1, size_type n1, const T& t, size_type pos2, size_type n2 = npos) const;

4
#

Effects: Эквивалентно: 

basic_string_view<charT, traits> sv = t;
return basic_string_view<charT, traits>(
    data(), size()).substr(pos1, n1).compare(sv.substr(pos2, n2));
5
#

Remarks: Эта функция не будет участвовать в разрешении перегрузки , если is_­convertible_­v<const T&, basic_­string_­view<charT, traits>> не true и is_­convertible_­v<const T&, const charT*> является false.

int compare(const basic_string& str) const noexcept;

6
#

Effects: Эквивалентно: return compare(basic_­string_­view<charT, traits>(str));

int compare(size_type pos1, size_type n1, const basic_string& str) const;

7
#

Effects: Эквивалентно: 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;

8
#

Effects: Эквивалентно: 

return compare(pos1, n1, basic_string_view<charT, traits>(str), pos2, n2);

int compare(const charT* s) const;

9
#

Returns: compare(basic_­string(s)).

int compare(size_type pos, size_type n1, const charT* s) const;

10
#

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;

11
#

Returns: basic_­string(*this, pos, n1).compare(basic_­string(s, n2)).

24.3.3 basic_­string non-member functions [string.nonmembers]

24.3.3.1 operator+ [string.op+]

template<class charT, class traits, class Allocator> basic_string<charT, traits, Allocator> operator+(const basic_string<charT, traits, Allocator>& lhs, const basic_string<charT, traits, Allocator>& rhs);

1
#

Returns: basic_­string<charT, traits, Allocator>(lhs).append(rhs).

template<class charT, class traits, class Allocator> basic_string<charT, traits, Allocator> operator+(basic_string<charT, traits, Allocator>&& lhs, const basic_string<charT, traits, Allocator>& rhs);

2
#

Returns: std​::​move(lhs.append(rhs)).

template<class charT, class traits, class Allocator> basic_string<charT, traits, Allocator> operator+(const basic_string<charT, traits, Allocator>& lhs, basic_string<charT, traits, Allocator>&& rhs);

3
#

Returns: std​::​move(rhs.insert(0, lhs)).

template<class charT, class traits, class Allocator> basic_string<charT, traits, Allocator> operator+(basic_string<charT, traits, Allocator>&& lhs, basic_string<charT, traits, Allocator>&& rhs);

4
#

Returns: std​::​move(lhs.append(rhs)). [  Note: Или то же самое, std​::​move(rhs.insert(0, lhs)). ]  — end note 

template<class charT, class traits, class Allocator> basic_string<charT, traits, Allocator> operator+(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs);

5
#

Returns: basic_­string<charT, traits, Allocator>(lhs) + rhs.

6
#

Remarks: Использует traits​::​length().

template<class charT, class traits, class Allocator> basic_string<charT, traits, Allocator> operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);

7
#

Returns: std​::​move(rhs.insert(0, lhs)).

8
#

Remarks: Использует traits​::​length().

template<class charT, class traits, class Allocator> basic_string<charT, traits, Allocator> operator+(charT lhs, const basic_string<charT, traits, Allocator>& rhs);

9
#

Returns: basic_­string<charT, traits, Allocator>(1, lhs) + rhs.

template<class charT, class traits, class Allocator> basic_string<charT, traits, Allocator> operator+(charT lhs, basic_string<charT, traits, Allocator>&& rhs);

10
#

Returns: std​::​move(rhs.insert(0, 1, lhs)).

template<class charT, class traits, class Allocator> basic_string<charT, traits, Allocator> operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);

11
#

Returns: lhs + basic_­string<charT, traits, Allocator>(rhs).

12
#

Remarks: Использует traits​::​length().

template<class charT, class traits, class Allocator> basic_string<charT, traits, Allocator> operator+(basic_string<charT, traits, Allocator>&& lhs, const charT* rhs);

13
#

Returns: std​::​move(lhs.append(rhs)).

14
#

Remarks: Использует traits​::​length().

template<class charT, class traits, class Allocator> basic_string<charT, traits, Allocator> operator+(const basic_string<charT, traits, Allocator>& lhs, charT rhs);

15
#

Returns: lhs + basic_­string<charT, traits, Allocator>(1, rhs).

template<class charT, class traits, class Allocator> basic_string<charT, traits, Allocator> operator+(basic_string<charT, traits, Allocator>&& lhs, charT rhs);

16
#

Returns: std​::​move(lhs.append(1, rhs)).

24.3.3.2 operator== [string.operator==]

template<class charT, class traits, class Allocator> bool operator==(const basic_string<charT, traits, Allocator>& lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;

1
#

Returns: lhs.compare(rhs) == 0.

template<class charT, class traits, class Allocator> bool operator==(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs);

2
#

Returns: rhs == lhs.

template<class charT, class traits, class Allocator> bool operator==(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);

3
#

Requires: rhs указывает на массив, состоящий как минимум из traits​::​length(rhs) + 1 элементов charT.

4
#

Returns: lhs.compare(rhs) == 0.

24.3.3.3 operator!= [string.op!=]

template<class charT, class traits, class Allocator> bool operator!=(const basic_string<charT, traits, Allocator>& lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;

1
#

Returns: !(lhs == rhs).

template<class charT, class traits, class Allocator> bool operator!=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs);

2
#

Returns: rhs != lhs.

template<class charT, class traits, class Allocator> bool operator!=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);

3
#

Requires: rhs указывает на массив, состоящий как минимум из traits​::​length(rhs) + 1 элементов charT.

4
#

Returns: lhs.compare(rhs) != 0.

24.3.3.4 operator< [string.op<]

template<class charT, class traits, class Allocator> bool operator< (const basic_string<charT, traits, Allocator>& lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;

1
#

Returns: lhs.compare(rhs) < 0.

template<class charT, class traits, class Allocator> bool operator< (const charT* lhs, const basic_string<charT, traits, Allocator>& rhs);

2
#

Returns: rhs.compare(lhs) > 0.

template<class charT, class traits, class Allocator> bool operator< (const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);

3
#

Returns: lhs.compare(rhs) < 0.

24.3.3.5 operator> [string.op>]

template<class charT, class traits, class Allocator> bool operator> (const basic_string<charT, traits, Allocator>& lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;

1
#

Returns: lhs.compare(rhs) > 0.

template<class charT, class traits, class Allocator> bool operator> (const charT* lhs, const basic_string<charT, traits, Allocator>& rhs);

2
#

Returns: rhs.compare(lhs) < 0.

template<class charT, class traits, class Allocator> bool operator> (const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);

3
#

Returns: lhs.compare(rhs) > 0.

24.3.3.6 operator<= [string.op<=]

template<class charT, class traits, class Allocator> bool operator<=(const basic_string<charT, traits, Allocator>& lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;

1
#

Returns: lhs.compare(rhs) <= 0.

template<class charT, class traits, class Allocator> bool operator<=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs);

2
#

Returns: rhs.compare(lhs) >= 0.

template<class charT, class traits, class Allocator> bool operator<=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);

3
#

Returns: lhs.compare(rhs) <= 0.

24.3.3.7 operator>= [string.op>=]

template<class charT, class traits, class Allocator> bool operator>=(const basic_string<charT, traits, Allocator>& lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;

1
#

Returns: lhs.compare(rhs) >= 0.

template<class charT, class traits, class Allocator> bool operator>=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs);

2
#

Returns: rhs.compare(lhs) <= 0.

template<class charT, class traits, class Allocator> bool operator>=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);

3
#

Returns: lhs.compare(rhs) >= 0.

24.3.3.8 swap [string.special]

template<class charT, class traits, class Allocator> void swap(basic_string<charT, traits, Allocator>& lhs, basic_string<charT, traits, Allocator>& rhs) noexcept(noexcept(lhs.swap(rhs)));

1
#

Effects: Эквивалентно: lhs.swap(rhs);

24.3.3.9 Inserters and extractors [string.io]

template<class charT, class traits, class Allocator> basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str);

1
#

Effects: Ведет себя как formatted input function. После создания sentry объекта, если часовой преобразуется в true, вызывает, str.erase() а затем извлекает символы из is и добавляет их, str как если бы, вызывая str.append(1, c). Если is.width() больше нуля, максимальное количество n добавляемых символов is.width(): в противном случае n это str.max_­size(). Символы извлекаются и добавляются до тех пор, пока не произойдет одно из следующих событий:

  • (1.1)

    n символы сохраняются;

  • (1.2)

    конец файла встречается во входной последовательности;

  • (1.3)

    isspace(c, is.getloc()) является true для следующего доступного входного символа c.

2
#

После извлечения последнего символа (если есть) вызывается is.width(0) и sentry объект уничтожается.

3
#

Если функция не извлекает символы, она вызывает is.setstate(ios​::​failbit), что может вызвать throw ios_­base​::​failure ([iostate.flags]).

4
#

Returns: is.

template<class charT, class traits, class Allocator> basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const basic_string<charT, traits, Allocator>& str);

5
#

Effects: Эквивалентно: return os << basic_­string_­view<charT, traits>(str);

template<class charT, class traits, class Allocator> basic_istream<charT, traits>& getline(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str, charT delim); template<class charT, class traits, class Allocator> basic_istream<charT, traits>& getline(basic_istream<charT, traits>&& is, basic_string<charT, traits, Allocator>& str, charT delim);

6
#

Effects: Ведет себя как объект unformatted input function, за исключением того, что не влияет на значение, возвращаемое при последующих вызовах basic_­istream<>​::​gcount(). После создания sentry объекта, если часовой преобразуется в true, вызывает, str.erase() а затем извлекает символы is и добавляет их, str как если бы, вызывая str.append(1, c) до тех пор, пока не произойдет одно из следующих событий:

  • (6.1)

    конец файла происходит во входной последовательности (в этом случае getline вызывается функция is.setstate(​ios_­base​::​eofbit)).

  • (6.2)

    traits​::​eq(c, delim) для следующего доступного входного символа c (в этом случае c извлекается, но не добавляется) ([iostate.flags])

  • (6.3)

    str.max_­size() символы сохраняются (в этом случае функция calls is.setstate(ios_­base​::​failbit)) ([iostate.flags])

7
#

Условия проверяются в указанном порядке. В любом случае после извлечения последнего символа sentry объект уничтожается.

8
#

Если функция не извлекает символы, она вызывает is.setstate(ios_­base​::​failbit) which may throw ios_­base​::​failure ([iostate.flags]).

9
#

Returns: is.

template<class charT, class traits, class Allocator> basic_istream<charT, traits>& getline(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str); template<class charT, class traits, class Allocator> basic_istream<charT, traits>& getline(basic_istream<charT, traits>&& is, basic_string<charT, traits, Allocator>& str);

10
#

Returns: getline(is, str, is.widen('\n')).

24.3.4 Numeric conversions [string.conversions]

int stoi(const string& str, size_t* idx = 0, int base = 10); long stol(const string& str, size_t* idx = 0, int base = 10); unsigned long stoul(const string& str, size_t* idx = 0, int base = 10); long long stoll(const string& str, size_t* idx = 0, int base = 10); unsigned long long stoull(const string& str, size_t* idx = 0, int base = 10);

1
#

Effects: первые два вызова функций strtol(str.c_­str(), ptr, base), а последние три вызова функций strtoul(str.c_­str(), ptr, base), strtoll(str.c_­str(), ptr, base)и strtoull(​str.c_­str(), ptr, base), соответственно. Каждая функция возвращает преобразованный результат, если таковой имеется. Аргумент ptr обозначает указатель на объект, внутренний по отношению к функции, который используется для определения того, что хранить *idx. Если функция не генерирует исключение и idx != 0, функция сохраняет *idx индекс первого неконвертированного элемента str.

2
#

Returns: Конвертированный результат.

3
#

Throws: invalid_­argument если strtol, strtoul, strtoll, или strtoull сообщает , что преобразование не может быть выполнено. Выдает , out_­of_­range если strtol, strtoul, strtoll или strtoull множества , errno чтобы ERANGE, или если преобразованное значение находится вне диапазона представимых значений для типа возврата.

float stof(const string& str, size_t* idx = 0); double stod(const string& str, size_t* idx = 0); long double stold(const string& str, size_t* idx = 0);

4
#

Effects: Эти функции называют strtof(str.c_­str(), ptr), strtod(str.c_­str(), ptr)и strtold(​str.c_­str(), ptr), соответственно. Каждая функция возвращает преобразованный результат, если таковой имеется. Аргумент ptr обозначает указатель на объект, внутренний по отношению к функции, который используется для определения того, что хранить *idx. Если функция не генерирует исключение и idx != 0, функция сохраняет *idx индекс первого неконвертированного элемента str.

5
#

Returns: Конвертированный результат.

6
#

Throws: invalid_­argument если strtof, strtodили strtold сообщает , что преобразование не может быть выполнено. Выдает ,out_­of_­range если strtof, strtodили strtold наборы , errno чтобы ERANGE или если преобразованное значение находится вне диапазона представимых значений для типа возврата.

string to_string(int val); string to_string(unsigned val); string to_string(long val); string to_string(unsigned long val); string to_string(long long val); string to_string(unsigned long long val); string to_string(float val); string to_string(double val); string to_string(long double val);

7
#

Returns: Каждая функция возвращает string объект , содержащий символьное представление значения его аргумента , который будет сгенерирован путем вызова sprintf(buf, fmt, val) с спецификатора форматом из "%d", "%u", "%ld", "%lu", "%lld", "%llu", "%f", "%f", или "%Lf", соответственно, где buf обозначает внутренний буфер символов достаточного размера.

int stoi(const wstring& str, size_t* idx = 0, int base = 10); long stol(const wstring& str, size_t* idx = 0, int base = 10); unsigned long stoul(const wstring& str, size_t* idx = 0, int base = 10); long long stoll(const wstring& str, size_t* idx = 0, int base = 10); unsigned long long stoull(const wstring& str, size_t* idx = 0, int base = 10);

8
#

Effects: первые два вызова функций wcstol(str.c_­str(), ptr, base), а последние три вызова функций wcstoul(str.c_­str(), ptr, base), wcstoll(str.c_­str(), ptr, base)и wcstoull(​str.c_­str(), ptr, base), соответственно. Каждая функция возвращает преобразованный результат, если таковой имеется. Аргумент ptr обозначает указатель на объект, внутренний по отношению к функции, который используется для определения того, что хранить *idx. Если функция не генерирует исключение и idx != 0, функция сохраняет *idx индекс первого неконвертированного элемента str.

9
#

Returns: Конвертированный результат.

10
#

Throws: invalid_­argument если wcstol, wcstoul, wcstoll, или wcstoull сообщает , что преобразование не может быть выполнено. Выбрасывается, out_­of_­range если преобразованное значение выходит за пределы диапазона представимых значений для возвращаемого типа.

float stof(const wstring& str, size_t* idx = 0); double stod(const wstring& str, size_t* idx = 0); long double stold(const wstring& str, size_t* idx = 0);

11
#

Effects: Эти функции называют wcstof(str.c_­str(), ptr), wcstod(str.c_­str(), ptr)и wcstold(​str.c_­str(), ptr), соответственно. Каждая функция возвращает преобразованный результат, если таковой имеется. Аргумент ptr обозначает указатель на объект, внутренний по отношению к функции, который используется для определения того, что хранить *idx. Если функция не генерирует исключение и idx != 0, функция сохраняет *idx индекс первого неконвертированного элемента str.

12
#

Returns: Конвертированный результат.

13
#

Throws: invalid_­argument если wcstof, wcstodили wcstold сообщает , что преобразование не может быть выполнено. Выбрасывает out_­of_­range if wcstof, wcstodили wcstold устанавливает errno значение ERANGE.

wstring to_wstring(int val); wstring to_wstring(unsigned val); wstring to_wstring(long val); wstring to_wstring(unsigned long val); wstring to_wstring(long long val); wstring to_wstring(unsigned long long val); wstring to_wstring(float val); wstring to_wstring(double val); wstring to_wstring(long double val);

14
#

Returns: Каждая функция возвращает wstring объект , содержащий символьное представление значения его аргумента , который будет сгенерирован путем вызова swprintf(buf, buffsz, fmt, val) с спецификатора форматом из L"%d", L"%u", L"%ld", L"%lu", L"%lld", L"%llu", L"%f", L"%f", или L"%Lf", соответственно, где buf обозначает внутренний буфер символов достаточного размера buffsz.

24.3.5 Hash support [basic.string.hash]

template<> struct hash<string>; template<> struct hash<u16string>; template<> struct hash<u32string>; template<> struct hash<wstring>;

1
#

Если S является одним из этих строковых типов, SV является соответствующим строковым типом представления и s является объектом типа S, то hash<S>()(s) == hash<SV>()(SV(s)).

24.3.6 Suffix for basic_­string literals [basic.string.literals]

string operator""s(const char* str, size_t len);

1
#

Returns: string{str, len}.

u16string operator""s(const char16_t* str, size_t len);

2
#

Returns: u16string{str, len}.

u32string operator""s(const char32_t* str, size_t len);

3
#

Returns: u32string{str, len}.

wstring operator""s(const wchar_t* str, size_t len);

4
#

Returns: wstring{str, len}.

5
#

[  Note: Тот же суффикс s используется для chrono​::​duration литералов, обозначающих секунды, но конфликта нет, поскольку суффиксы продолжительности применяются к числам, а суффиксы строковых литералов - к литералам массива символов. ] — end note 

24.4 String view classes [string.view]

1
#

Шаблон класса basic_­string_­view описывает объект, который может ссылаться на постоянную непрерывную последовательность char-like objects с первым элементом последовательности в нулевой позиции. В остальной части этого раздела тип char-подобных объектов, содержащихся в basic_­string_­view объекте, обозначается с помощью charT.

2
#

[  Note: Библиотека обеспечивает неявное преобразование из const charT* и std​::​basic_­string<charT, ...> в, std​::​basic_­string_­view<charT, ...> чтобы пользовательский код мог принимать std​::​basic_­string_­view<charT> как параметр, не являющийся шаблоном, везде, где ожидается последовательность символов. Пользовательские типы должны определять свои собственные неявные преобразования std​::​basic_­string_­view в, чтобы взаимодействовать с этими функциями. ] — end note 

3
#

Если не указано иное, сложность basic_­string_­view функций-членов O(1) не указана.

24.4.1 Header <string_­view> synopsis [string.view.synop]

namespace std {
  // [string.view.template], class template basic_­string_­view
  template<class charT, class traits = char_traits<charT>>
  class basic_string_view;

  // [string.view.comparison], non-member comparison functions
  template<class charT, class traits>
    constexpr bool operator==(basic_string_view<charT, traits> x,
                              basic_string_view<charT, traits> y) noexcept;
  template<class charT, class traits>
    constexpr bool operator!=(basic_string_view<charT, traits> x,
                              basic_string_view<charT, traits> y) noexcept;
  template<class charT, class traits>
    constexpr bool operator< (basic_string_view<charT, traits> x,
                              basic_string_view<charT, traits> y) noexcept;
  template<class charT, class traits>
    constexpr bool operator> (basic_string_view<charT, traits> x,
                              basic_string_view<charT, traits> y) noexcept;
  template<class charT, class traits>
    constexpr bool operator<=(basic_string_view<charT, traits> x,
                              basic_string_view<charT, traits> y) noexcept;
  template<class charT, class traits>
    constexpr bool operator>=(basic_string_view<charT, traits> x,
                              basic_string_view<charT, traits> y) noexcept;
  // see [string.view.comparison], sufficient additional overloads of comparison functions

  // [string.view.io], inserters and extractors
  template<class charT, class traits>
    basic_ostream<charT, traits>&
      operator<<(basic_ostream<charT, traits>& os,
                 basic_string_view<charT, traits> str);

  // basic_­string_­view typedef names
  using string_view    = basic_string_view<char>;
  using u16string_view = basic_string_view<char16_t>;
  using u32string_view = basic_string_view<char32_t>;
  using wstring_view   = basic_string_view<wchar_t>;

  // [string.view.hash], hash support
  template<class T> struct hash;
  template<> struct hash<string_view>;
  template<> struct hash<u16string_view>;
  template<> struct hash<u32string_view>;
  template<> struct hash<wstring_view>;

  inline namespace literals {
  inline namespace string_view_literals {
    // [string.view.literals], suffix for basic_­string_­view literals
    constexpr string_view    operator""sv(const char* str, size_t len) noexcept;
    constexpr u16string_view operator""sv(const char16_t* str, size_t len) noexcept;
    constexpr u32string_view operator""sv(const char32_t* str, size_t len) noexcept;
    constexpr wstring_view   operator""sv(const wchar_t* str, size_t len) noexcept;
  }
  }
}
1
#

Шаблоны функций, определенные в [utility.swap] и [iterator.range] доступны, если они <string_­view> включены.

24.4.2 Class template basic_­string_­view [string.view.template]

template<class charT, class traits = char_traits<charT>>
class basic_string_view {
public:
  // types
  using traits_type            = traits;
  using value_type             = charT;
  using pointer                = value_type*;
  using const_pointer          = const value_type*;
  using reference              = value_type&;
  using const_reference        = const value_type&;
  using const_iterator         = implementation-defined; // see [string.view.iterators]
  using iterator               = const_iterator;228
  using const_reverse_iterator = reverse_iterator<const_iterator>;
  using reverse_iterator       = const_reverse_iterator;
  using size_type              = size_t;
  using difference_type        = ptrdiff_t;
  static constexpr size_type npos = size_type(-1);

  // [string.view.cons], construction and assignment
  constexpr basic_string_view() noexcept;
  constexpr basic_string_view(const basic_string_view&) noexcept = default;
  constexpr basic_string_view& operator=(const basic_string_view&) noexcept = default;
  constexpr basic_string_view(const charT* str);
  constexpr basic_string_view(const charT* str, size_type len);

  // [string.view.iterators], iterator support
  constexpr const_iterator begin() const noexcept;
  constexpr const_iterator end() const noexcept;
  constexpr const_iterator cbegin() const noexcept;
  constexpr const_iterator cend() const noexcept;
  constexpr const_reverse_iterator rbegin() const noexcept;
  constexpr const_reverse_iterator rend() const noexcept;
  constexpr const_reverse_iterator crbegin() const noexcept;
  constexpr const_reverse_iterator crend() const noexcept;

  // [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;
  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
  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 size_type find(basic_string_view s, size_type pos = 0) const noexcept;
  constexpr size_type find(charT c, size_type pos = 0) const noexcept;
  constexpr size_type find(const charT* s, size_type pos, size_type n) const;
  constexpr size_type find(const charT* s, size_type pos = 0) const;
  constexpr size_type rfind(basic_string_view s, size_type pos = npos) const noexcept;
  constexpr size_type rfind(charT c, size_type pos = npos) const noexcept;
  constexpr size_type rfind(const charT* s, size_type pos, size_type n) const;
  constexpr size_type rfind(const charT* s, size_type pos = npos) const;
  constexpr size_type find_first_of(basic_string_view s, size_type pos = 0) const noexcept;
  constexpr size_type find_first_of(charT c, size_type pos = 0) const noexcept;
  constexpr size_type find_first_of(const charT* s, size_type pos, size_type n) const;
  constexpr size_type find_first_of(const charT* s, size_type pos = 0) const;
  constexpr size_type find_last_of(basic_string_view s, size_type pos = npos) const noexcept;
  constexpr size_type find_last_of(charT c, size_type pos = npos) const noexcept;
  constexpr size_type find_last_of(const charT* s, size_type pos, size_type n) const;
  constexpr size_type find_last_of(const charT* s, size_type pos = npos) const;
  constexpr size_type find_first_not_of(basic_string_view s, size_type pos = 0) const noexcept;
  constexpr size_type find_first_not_of(charT c, size_type pos = 0) const noexcept;
  constexpr size_type find_first_not_of(const charT* s, size_type pos,
                                        size_type n) const;
  constexpr size_type find_first_not_of(const charT* s, size_type pos = 0) const;
  constexpr size_type find_last_not_of(basic_string_view s,
                                       size_type pos = npos) const noexcept;
  constexpr size_type find_last_not_of(charT c, size_type pos = npos) const noexcept;
  constexpr size_type find_last_not_of(const charT* s, size_type pos,
                                       size_type n) const;
  constexpr size_type find_last_not_of(const charT* s, size_type pos = npos) const;

private:
  const_pointer data_; // exposition only
  size_type size_;     // exposition only
};
1
#

В каждой специализации basic_­string_­view<charT, traits>тип traits должен удовлетворять требованиям к характеристикам символов ([char.traits]), и тип traits​::​char_­type должен называть тот же тип, что и charT.

228)

Потому что basic_­string_­view относится к постоянной последовательности iterator и const_­iterator относятся к одному типу.

24.4.2.1 Construction and assignment [string.view.cons]

constexpr basic_string_view() noexcept;

1
#

Effects: Создает пустой basic_­string_­view.

2
#

Postconditions: size_­ == 0 и data_­ == nullptr.

constexpr basic_string_view(const charT* str);

3
#

Requires: [str, str + traits​::​length(str)) допустимый диапазон.

4
#

Effects: Создает a basic_­string_­viewс постусловиями из Табл 64.

Таблица 64 - basic_­string_­view(const charT*) эффекты
ЭлементЦенить
data_­ str
size_­ traits​::​length(str)
5
#

Complexity: O(traits::length(str)).

constexpr basic_string_view(const charT* str, size_type len);

6
#

Requires: [str, str + len) допустимый диапазон.

7
#

Effects: Создает a basic_­string_­viewс постусловиями из Табл 65.

Таблица 65 - basic_­string_­view(const charT*, size_­type) эффекты
ЭлементЦенить
data_­ str
size_­ len

24.4.2.2 Iterator support [string.view.iterators]

using const_iterator = implementation-defined;

1
#

Тип, отвечающий требованиям постоянного итератора произвольного доступа ([random.access.iterators]) и непрерывного итератора ([iterator.requirements.general]), который value_­type является параметром шаблона charT.

2
#

Для a basic_­string_­view strлюбая операция, которая делает недействительным указатель в диапазоне, [str.data(), str.data() + str.size()) делает недействительными указатели, итераторы и ссылки, возвращаемые из strметодов.

3
#

Все требования к контейнерным итераторам ([container.requirements]) также применимы basic_­string_­view​::​const_­iterator .

constexpr const_iterator begin() const noexcept; constexpr const_iterator cbegin() const noexcept;

4
#

Returns: Итератор такой, что

  • (4.1)

    если !empty(), &*begin() == data_­,

  • (4.2)

    в противном случае - неопределенное значение, такое [begin(), end()) как допустимый диапазон.

constexpr const_iterator end() const noexcept; constexpr const_iterator cend() const noexcept;

5
#

Returns: begin() + size().

constexpr const_reverse_iterator rbegin() const noexcept; constexpr const_reverse_iterator crbegin() const noexcept;

6
#

Returns: const_­reverse_­iterator(end()).

constexpr const_reverse_iterator rend() const noexcept; constexpr const_reverse_iterator crend() const noexcept;

7
#

Returns: const_­reverse_­iterator(begin()).

24.4.2.3 Capacity [string.view.capacity]

constexpr size_type size() const noexcept;

1
#

Returns: size_­.

constexpr size_type length() const noexcept;

2
#

Returns: size_­.

constexpr size_type max_size() const noexcept;

3
#

Returns: Максимально возможное количество символьных объектов, на которые может ссылаться a basic_­string_­view.

constexpr bool empty() const noexcept;

4
#

Returns: size_­ == 0.

24.4.2.4 Element access [string.view.access]

constexpr const_reference operator[](size_type pos) const;

1
#

Requires: pos < size().

2
#

Returns: data_­[pos].

3
#

Throws: Ничего такого.

4
#

[  Note: В отличие от basic_­string​::​operator[], basic_­string_­view​::​operator[](size()) имеет неопределенное поведение вместо возврата charT(). ]  — end note 

constexpr const_reference at(size_type pos) const;

5
#

Throws: out_­of_­range если pos >= size().

6
#

Returns: data_­[pos].

constexpr const_reference front() const;

7
#

Requires: !empty().

8
#

Returns: data_­[0].

9
#

Throws: Ничего такого.

constexpr const_reference back() const;

10
#

Requires: !empty().

11
#

Returns: data_­[size() - 1].

12
#

Throws: Ничего такого.

constexpr const_pointer data() const noexcept;

13
#

Returns: data_­.

14
#

[  Note: В отличие от basic_­string​::​data() строковых литералов и, data() может возвращать указатель на буфер, не оканчивающийся нулем. Поэтому переход data() к функции, которая принимает только a const charT* и ожидает строку с завершающим нулем, является ошибкой . ]  — end note 

24.4.2.5 Modifiers [string.view.modifiers]

constexpr void remove_prefix(size_type n);

1
#

Requires: n <= size().

2
#

Effects: Эквивалентно: data_­ += n; size_­ -= n;

constexpr void remove_suffix(size_type n);

3
#

Requires: n <= size().

4
#

Effects: Эквивалентно: size_­ -= n;

constexpr void swap(basic_string_view& s) noexcept;

5
#

Effects: Меняет значения *this и s.

24.4.2.6 String operations [string.view.ops]

size_type copy(charT* s, size_type n, size_type pos = 0) const;

1
#

Позвольте rlen быть меньшим из n и size() - pos.

2
#

Throws: out_­of_­range если pos > size().

3
#

Requires: [s, s + rlen) допустимый диапазон.

4
#

Effects: Эквивалентно traits​::​copy(s, data() + pos, rlen).

5
#

Returns: rlen.

6
#

Complexity: O(rlen).

constexpr basic_string_view substr(size_type pos = 0, size_type n = npos) const;

7
#

Позвольте rlen быть меньшим из n и size() - pos.

8
#

Throws: out_­of_­range если pos > size().

9
#

Effects: Определяет rlenэффективную длину строки для ссылки.

10
#

Returns: basic_­string_­view(data() + pos, rlen).

constexpr int compare(basic_string_view str) const noexcept;

11
#

Позвольте rlen быть меньшим из size() и str.size().

12
#

Effects: Определяет rlenэффективную длину сравниваемых строк. Затем функция сравнивает две строки, вызывая traits​::​compare(data(), str.data(), rlen).

13
#

Complexity: O(rlen).

14
#

Returns: Ненулевой результат, если результат сравнения отличен от нуля. В противном случае возвращает значение, указанное в таблице 66.

Таблица 66 - compare() результаты
СостояниеВозвращаемое значение
size() < str.size() < 0
size() == str.size()  0
size() > str.size() > 0

constexpr int compare(size_type pos1, size_type n1, basic_string_view str) const;

15
#

Effects: Эквивалентно: return substr(pos1, n1).compare(str);

constexpr int compare(size_type pos1, size_type n1, basic_string_view str, size_type pos2, size_type n2) const;

16
#

Effects: Эквивалентно: return substr(pos1, n1).compare(str.substr(pos2, n2));

constexpr int compare(const charT* s) const;

17
#

Effects: Эквивалентно: return compare(basic_­string_­view(s));

constexpr int compare(size_type pos1, size_type n1, const charT* s) const;

18
#

Effects: Эквивалентно: return substr(pos1, n1).compare(basic_­string_­view(s));

constexpr int compare(size_type pos1, size_type n1, const charT* s, size_type n2) const;

19
#

Effects: Эквивалентно: return substr(pos1, n1).compare(basic_­string_­view(s, n2));

24.4.2.7 Searching [string.view.find]

1
#

В этом разделе описываются basic_­string_­view функции - члены с именем find, rfind, find_­first_­of, find_­last_­of, find_­first_­not_­of, и find_­last_­not_­of.

2
#

Функции-члены в этом разделе O(size() * str.size()) в худшем случае сложны, хотя реализациям рекомендуется работать лучше.

3
#

Каждая функция-член формы 

constexpr return-type F(const charT* s, size_type pos);

эквивалентно return F(basic_­string_­view(s), pos);

4
#

Каждая функция-член формы 

constexpr return-type F(const charT* s, size_type pos, size_type n);

эквивалентно return F(basic_­string_­view(s, n), pos);

5
#

Каждая функция-член формы 

constexpr return-type F(charT c, size_type pos);

эквивалентно return F(basic_­string_­view(&c, 1), pos);

constexpr size_type find(basic_string_view str, size_type pos = 0) const noexcept;

6
#

Позвольте xpos быть самой низкой позицией, если возможно, такой, что выполняются следующие условия:

  • (6.1)

    pos <= xpos

  • (6.2)

    xpos + str.size() <= size()

  • (6.3)

    traits​::​eq(at(xpos + I), str.at(I)) для всех элементов I строки, на которую ссылается str.

7
#

Effects: Определяет xpos.

8
#

Returns: xpos если функция может определить такое значение для xpos. В противном случае возвращается npos.

constexpr size_type rfind(basic_string_view str, size_type pos = npos) const noexcept;

9
#

Позвольте xpos быть высшей позицией, если возможно, такой, что выполняются следующие условия:

  • (9.1)

    xpos <= pos

  • (9.2)

    xpos + str.size() <= size()

  • (9.3)

    traits​::​eq(at(xpos + I), str.at(I)) для всех элементов I строки, на которую ссылается str.

10
#

Effects: Определяет xpos.

11
#

Returns: xpos если функция может определить такое значение для xpos. В противном случае возвращается npos.

constexpr size_type find_first_of(basic_string_view str, size_type pos = 0) const noexcept;

12
#

Позвольте xpos быть самой низкой позицией, если возможно, такой, что выполняются следующие условия:

  • (12.1)

    pos <= xpos

  • (12.2)

    xpos < size()

  • (12.3)

    traits​::​eq(at(xpos), str.at(I)) для некоторого элемента I строки, на которую ссылается str.

13
#

Effects: Определяет xpos.

14
#

Returns: xpos если функция может определить такое значение для xpos. В противном случае возвращается npos.

constexpr size_type find_last_of(basic_string_view str, size_type pos = npos) const noexcept;

15
#

Позвольте xpos быть высшей позицией, если возможно, такой, что выполняются следующие условия:

  • (15.1)

    xpos <= pos

  • (15.2)

    xpos < size()

  • (15.3)

    traits​::​eq(at(xpos), str.at(I)) для некоторого элемента I строки, на которую ссылается str.

16
#

Effects: Определяет xpos.

17
#

Returns: xpos если функция может определить такое значение для xpos. В противном случае возвращается npos.

constexpr size_type find_first_not_of(basic_string_view str, size_type pos = 0) const noexcept;

18
#

Позвольте xpos быть самой низкой позицией, если возможно, такой, что выполняются следующие условия:

  • (18.1)

    pos <= xpos

  • (18.2)

    xpos < size()

  • (18.3)

    traits​::​eq(at(xpos), str.at(I)) для ни одного элемента I строки, на которую ссылается str.

19
#

Effects: Определяет xpos.

20
#

Returns: xpos если функция может определить такое значение для xpos. В противном случае возвращается npos.

constexpr size_type find_last_not_of(basic_string_view str, size_type pos = npos) const noexcept;

21
#

Позвольте xpos быть высшей позицией, если возможно, такой, что выполняются следующие условия:

  • (21.1)

    xpos <= pos

  • (21.2)

    xpos < size()

  • (21.3)

    traits​::​eq(at(xpos), str.at(I)) для ни одного элемента I строки, на которую ссылается str.

22
#

Effects: Определяет xpos.

23
#

Returns: xpos если функция может определить такое значение для xpos. В противном случае возвращается npos.

24.4.3 Non-member comparison functions [string.view.comparison]

1
#

Позвольте S быть basic_­string_­view<charT, traits>, и sv быть экземпляром S. Реализации должны обеспечить достаточные дополнительные перегрузки , отмеченные constexpr и noexcept таким образом , чтобы объект t с неявным преобразованием , чтобы S можно сравнить в соответствии с таблицей 67.

Таблица 67 - Дополнительные basic_­string_­view перегрузки для сравнения
ВыражениеЭквивалентно
t == sv S(t) == sv
sv == t sv == S(t)
t != sv S(t) != sv
sv != t sv != S(t)
t < sv S(t) < sv
sv < t sv < S(t)
t > sv S(t) > sv
sv > t sv > S(t)
t <= sv S(t) <= sv
sv <= t sv <= S(t)
t >= sv S(t) >= sv
sv >= t sv >= S(t)

[  Example: Пример соответствующей реализации для operator== : 

template<class T> using __identity = decay_t<T>;
template<class charT, class traits>
  constexpr bool operator==(basic_string_view<charT, traits> lhs,
                            basic_string_view<charT, traits> rhs) noexcept {
    return lhs.compare(rhs) == 0;
  }
template<class charT, class traits>
  constexpr bool operator==(basic_string_view<charT, traits> lhs,
                            __identity<basic_string_view<charT, traits>> rhs) noexcept {
    return lhs.compare(rhs) == 0;
  }
template<class charT, class traits>
  constexpr bool operator==(__identity<basic_string_view<charT, traits>> lhs,
                            basic_string_view<charT, traits> rhs) noexcept {
    return lhs.compare(rhs) == 0;
  }

 — end example ]

template<class charT, class traits> constexpr bool operator==(basic_string_view<charT, traits> lhs, basic_string_view<charT, traits> rhs) noexcept;

2
#

Returns: lhs.compare(rhs) == 0.

template<class charT, class traits> constexpr bool operator!=(basic_string_view<charT, traits> lhs, basic_string_view<charT, traits> rhs) noexcept;

3
#

Returns: lhs.compare(rhs) != 0.

template<class charT, class traits> constexpr bool operator< (basic_string_view<charT, traits> lhs, basic_string_view<charT, traits> rhs) noexcept;

4
#

Returns: lhs.compare(rhs) < 0.

template<class charT, class traits> constexpr bool operator> (basic_string_view<charT, traits> lhs, basic_string_view<charT, traits> rhs) noexcept;

5
#

Returns: lhs.compare(rhs) > 0.

template<class charT, class traits> constexpr bool operator<=(basic_string_view<charT, traits> lhs, basic_string_view<charT, traits> rhs) noexcept;

6
#

Returns: lhs.compare(rhs) <= 0.

template<class charT, class traits> constexpr bool operator>=(basic_string_view<charT, traits> lhs, basic_string_view<charT, traits> rhs) noexcept;

7
#

Returns: lhs.compare(rhs) >= 0.

24.4.4 Inserters and extractors [string.view.io]

template<class charT, class traits> basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, basic_string_view<charT, traits> str);

1
#

Effects: Ведет себя как formatted output function оф os. Формирует последовательность символов seq, изначально состоящую из элементов, определенных диапазоном [str.begin(), str.end()). Определяет заполнение, seq как описано в [ostream.formatted.reqmts]. Затем вставляет seq как бы по вызову os.rdbuf()->sputn(​seq, n), где n больше из os.width() и str.size(); потом звонит os.​width(0).

2
#

Returns: os

24.4.5 Hash support [string.view.hash]

template<> struct hash<string_view>; template<> struct hash<u16string_view>; template<> struct hash<u32string_view>; template<> struct hash<wstring_view>;

1
#

Специализация включена ([unord.hash]). [  Note: Хеш-значение объекта строкового представления равно хэш-значению соответствующего строкового объекта ([basic.string.hash]). ]  — end note 

24.4.6 Suffix for basic_­string_­view literals [string.view.literals]

constexpr string_view operator""sv(const char* str, size_t len) noexcept;

1
#

Returns: string_­view{str, len}.

constexpr u16string_view operator""sv(const char16_t* str, size_t len) noexcept;

2
#

Returns: u16string_­view{str, len}.

constexpr u32string_view operator""sv(const char32_t* str, size_t len) noexcept;

3
#

Returns: u32string_­view{str, len}.

constexpr wstring_view operator""sv(const wchar_t* str, size_t len) noexcept;

4
#

Returns: wstring_­view{str, len}.

24.5 Null-terminated sequence utilities [c.strings]

24.5.1 Header <cctype> synopsis [cctype.syn]

namespace std {
  int isalnum(int c);
  int isalpha(int c);
  int isblank(int c);
  int iscntrl(int c);
  int isdigit(int c);
  int isgraph(int c);
  int islower(int c);
  int isprint(int c);
  int ispunct(int c);
  int isspace(int c);
  int isupper(int c);
  int isxdigit(int c);
  int tolower(int c);
  int toupper(int c);
}
1
#

Содержание и значение заголовка <cctype> такие же , как заголовок стандартной библиотеки C <ctype.h>.

См. Также: ISO C 7.4.

24.5.2 Header <cwctype> synopsis [cwctype.syn]

namespace std {
  using wint_t = see below;
  using wctrans_t = see below;
  using wctype_t = see below;

  int iswalnum(wint_t wc);
  int iswalpha(wint_t wc);
  int iswblank(wint_t wc);
  int iswcntrl(wint_t wc);
  int iswdigit(wint_t wc);
  int iswgraph(wint_t wc);
  int iswlower(wint_t wc);
  int iswprint(wint_t wc);
  int iswpunct(wint_t wc);
  int iswspace(wint_t wc);
  int iswupper(wint_t wc);
  int iswxdigit(wint_t wc);
  int iswctype(wint_t wc, wctype_t desc);
  wctype_t wctype(const char* property);
  wint_t towlower(wint_t wc);
  wint_t towupper(wint_t wc);
  wint_t towctrans(wint_t wc, wctrans_t desc);
  wctrans_t wctrans(const char* property);
}

#define WEOF see below
1
#

Содержание и значение заголовка <cwctype> такие же , как заголовок стандартной библиотеки C <wctype.h>.

См. Также: ISO C 7.30

24.5.3 Header <cstring> synopsis [cstring.syn]

namespace std {
  using size_t = see [support.types.layout];

  void* memcpy(void* s1, const void* s2, size_t n);
  void* memmove(void* s1, const void* s2, size_t n);
  char* strcpy(char* s1, const char* s2);
  char* strncpy(char* s1, const char* s2, size_t n);
  char* strcat(char* s1, const char* s2);
  char* strncat(char* s1, const char* s2, size_t n);
  int memcmp(const void* s1, const void* s2, size_t n);
  int strcmp(const char* s1, const char* s2);
  int strcoll(const char* s1, const char* s2);
  int strncmp(const char* s1, const char* s2, size_t n);
  size_t strxfrm(char* s1, const char* s2, size_t n);
  const void* memchr(const void* s, int c, size_t n);  // see [library.c]
  void* memchr(void* s, int c, size_t n)  // see [library.c]
  const char* strchr(const char* s, int c)  // see [library.c]
  char* strchr(char* s, int c)  // see [library.c]
  size_t strcspn(const char* s1, const char* s2);
  const char* strpbrk(const char* s1, const char* s2)  // see [library.c]
  char* strpbrk(char* s1, const char* s2)  // see [library.c]
  const char* strrchr(const char* s, int c)  // see [library.c]
  char* strrchr(char* s, int c)  // see [library.c]
  size_t strspn(const char* s1, const char* s2);
  const char* strstr(const char* s1, const char* s2)  // see [library.c]
  char* strstr(char* s1, const char* s2)  // see [library.c]
  char* strtok(char* s1, const char* s2);
  void* memset(void* s, int c, size_t n);
  char* strerror(int errnum);
  size_t strlen(const char* s);
}

#define NULL see [support.types.nullptr]
1
#

Содержание и значение заголовка <cstring> такие же , как заголовок стандартной библиотеки C <string.h>.

2
#

Функции strerror и strtok не требуются avoid data races.

3
#

Функции memcpy и memmove безопасны для сигналов ([csignal.syn]).

4
#

[  Note: Функция strchr, strpbrk, strrchr, strstr, и memchr, имеют разные подписи в настоящем стандарте, но они имеют такое же поведение , как и в C standard library. ] — end note 

См. Также: ISO C 7.24.

24.5.4 Header <cwchar> synopsis [cwchar.syn]

namespace std {
  using size_t = see [support.types.layout];
  using mbstate_t = see below;
  using wint_t = see below;

  struct tm;

  int fwprintf(FILE* stream, const wchar_t* format, ...);
  int fwscanf(FILE* stream, const wchar_t* format, ...);
  int swprintf(wchar_t* s, size_t n, const wchar_t* format, ...);
  int swscanf(const wchar_t* s, const wchar_t* format, ...);
  int vfwprintf(FILE* stream, const wchar_t* format, va_list arg);
  int vfwscanf(FILE* stream, const wchar_t* format, va_list arg);
  int vswprintf(wchar_t* s, size_t n, const wchar_t* format, va_list arg);
  int vswscanf(const wchar_t* s, const wchar_t* format, va_list arg);
  int vwprintf(const wchar_t* format, va_list arg);
  int vwscanf(const wchar_t* format, va_list arg);
  int wprintf(const wchar_t* format, ...);
  int wscanf(const wchar_t* format, ...);
  wint_t fgetwc(FILE* stream);
  wchar_t* fgetws(wchar_t* s, int n, FILE* stream);
  wint_t fputwc(wchar_t c, FILE* stream);
  int fputws(const wchar_t* s, FILE* stream);
  int fwide(FILE* stream, int mode);
  wint_t getwc(FILE* stream);
  wint_t getwchar();
  wint_t putwc(wchar_t c, FILE* stream);
  wint_t putwchar(wchar_t c);
  wint_t ungetwc(wint_t c, FILE* stream);
  double wcstod(const wchar_t* nptr, wchar_t** endptr);
  float wcstof(const wchar_t* nptr, wchar_t** endptr);
  long double wcstold(const wchar_t* nptr, wchar_t** endptr);
  long int wcstol(const wchar_t* nptr, wchar_t** endptr, int base);
  long long int wcstoll(const wchar_t* nptr, wchar_t** endptr, int base);
  unsigned long int wcstoul(const wchar_t* nptr, wchar_t** endptr, int base);
  unsigned long long int wcstoull(const wchar_t* nptr, wchar_t** endptr, int base);
  wchar_t* wcscpy(wchar_t* s1, const wchar_t* s2);
  wchar_t* wcsncpy(wchar_t* s1, const wchar_t* s2, size_t n);
  wchar_t* wmemcpy(wchar_t* s1, const wchar_t* s2, size_t n);
  wchar_t* wmemmove(wchar_t* s1, const wchar_t* s2, size_t n);
  wchar_t* wcscat(wchar_t* s1, const wchar_t* s2);
  wchar_t* wcsncat(wchar_t* s1, const wchar_t* s2, size_t n);
  int wcscmp(const wchar_t* s1, const wchar_t* s2);
  int wcscoll(const wchar_t* s1, const wchar_t* s2);
  int wcsncmp(const wchar_t* s1, const wchar_t* s2, size_t n);
  size_t wcsxfrm(wchar_t* s1, const wchar_t* s2, size_t n);
  int wmemcmp(const wchar_t* s1, const wchar_t* s2, size_t n);
  const wchar_t* wcschr(const wchar_t* s, wchar_t c)  // see [library.c]
  wchar_t* wcschr(wchar_t* s, wchar_t c)  // see [library.c]
  size_t wcscspn(const wchar_t* s1, const wchar_t* s2);
  const wchar_t* wcspbrk(const wchar_t* s1, const wchar_t* s2)  // see [library.c]
  wchar_t* wcspbrk(wchar_t* s1, const wchar_t* s2)  // see [library.c]
  const wchar_t* wcsrchr(const wchar_t* s, wchar_t c)  // see [library.c]
  wchar_t* wcsrchr(wchar_t* s, wchar_t c)  // see [library.c]
  size_t wcsspn(const wchar_t* s1, const wchar_t* s2);
  const wchar_t* wcsstr(const wchar_t* s1, const wchar_t* s2)  // see [library.c]
  wchar_t* wcsstr(wchar_t* s1, const wchar_t* s2)  // see [library.c]
  wchar_t* wcstok(wchar_t* s1, const wchar_t* s2, wchar_t** ptr);
  const wchar_t* wmemchr(const wchar_t* s, wchar_t c, size_t n)  // see [library.c]
  wchar_t* wmemchr(wchar_t* s, wchar_t c, size_t n)  // see [library.c]
  size_t wcslen(const wchar_t* s);
  wchar_t* wmemset(wchar_t* s, wchar_t c, size_t n);
  size_t wcsftime(wchar_t* s, size_t maxsize, const wchar_t* format, const struct tm* timeptr);
  wint_t btowc(int c);
  int wctob(wint_t c);

  // [c.mb.wcs], multibyte / wide string and character conversion functions
  int mbsinit(const mbstate_t* ps);
  size_t mbrlen(const char* s, size_t n, mbstate_t* ps);
  size_t mbrtowc(wchar_t* pwc, const char* s, size_t n, mbstate_t* ps);
  size_t wcrtomb(char* s, wchar_t wc, mbstate_t* ps);
  size_t mbsrtowcs(wchar_t* dst, const char** src, size_t len, mbstate_t* ps);
  size_t wcsrtombs(char* dst, const wchar_t** src, size_t len, mbstate_t* ps);
}

#define NULL see [support.types.nullptr]
#define WCHAR_MAX see below
#define WCHAR_MIN see below
#define WEOF see below
1
#

Содержание и значение заголовка <cwchar> такие же, как и у заголовка стандартной библиотеки C <wchar.h>, за исключением того, что он не объявляет тип wchar_­t.

2
#

[  Note: Функция wcschr, wcspbrk, wcsrchr, wcsstr, и wmemchr имеют разные подписи в настоящем стандарте, но они имеют такое же поведение , как и в C standard library. ] — end note 

См. Также: ISO C 7.29

24.5.5 Header <cuchar> synopsis [cuchar.syn]

namespace std {
  using mbstate_t = see below;
  using size_t = see [support.types.layout];

  size_t mbrtoc16(char16_t* pc16, const char* s, size_t n, mbstate_t* ps);
  size_t c16rtomb(char* s, char16_t c16, mbstate_t* ps);
  size_t mbrtoc32(char32_t* pc32, const char* s, size_t n, mbstate_t* ps);
  size_t c32rtomb(char* s, char32_t c32, mbstate_t* ps);
}
1
#

Содержимое и значение заголовка <cuchar> такие же, как и заголовок стандартной библиотеки C <uchar.h>, за исключением того, что он не объявляет char16_­t ни типы, ни char32_­t.

См. Также: ISO C 7.28

24.5.6 Multibyte / wide string and character conversion functions [c.mb.wcs]

1
#

[  Note: Заголовки <cstdlib> и <cwchar> объявляют функции, описанные в этом подпункте. ] — end note 

int mbsinit(const mbstate_t* ps); int mblen(const char* s, size_t n); size_t mbstowcs(wchar_t* pwcs, const char* s, size_t n); size_t wcstombs(char* s, const wchar_t* pwcs, size_t n);

2
#

Effects: Эти функции имеют семантику, указанную в стандартной библиотеке C.

См. Также: ISO C 7.22.7.1, 7.22.8, 7.29.6.2.1

int mbtowc(wchar_t* pwc, const char* s, size_t n); int wctomb(char* s, wchar_t wchar);

3
#

Effects: Эти функции имеют семантику, указанную в стандартной библиотеке C.

4
#

Remarks: Вызов этих функций может вызвать гонку данных ([res.on.data.races]) с другими вызовами той же функции.

См. Также: ISO C 7.22.7

size_t mbrlen(const char* s, size_t n, mbstate_t* ps); size_t mbrtowc(wchar_t* pwc, const char* s, size_t n, mbstate_t* ps); size_t wcrtomb(char* s, wchar_t wc, mbstate_t* ps); size_t mbsrtowcs(wchar_t* dst, const char** src, size_t len, mbstate_t* ps); size_t wcsrtombs(char* dst, const wchar_t** src, size_t len, mbstate_t* ps);

5
#

Effects: Эти функции имеют семантику, указанную в стандартной библиотеке C.

6
#

Remarks: Вызов этих функций с mbstate_­t* аргументом, который является значением нулевого указателя, может вызвать гонку данных ([res.on.data.races]) с другими вызовами той же функции с mbstate_­t* аргументом, который является значением нулевого указателя.

См. Также: ISO C 7.29.6.3.