标准库标头 <string>

See More

 

C++

编译器支持

自立实现与有宿主实现

语言

标准库

标准库标头

具名要求

功能特性测试宏 (C++20)

语言支持库

概念库 (C++20)

诊断库

内存管理库

元编程库 (C++11)

通用工具库

容器库

迭代器库

范围库 (C++20)

算法库

字符串库

文本处理库

数值库

日期和时间库

输入/输出库

文件系统库 (C++17)

并发支持库 (C++11)

执行控制库 (C++26)

技术规范

符号索引

外部库

 

标准库头

语言支持 <cfloat> <climits> <compare> (C++20) <contracts> (C++26) <coroutine> (C++20) <csetjmp> <csignal> <cstdarg> <cstddef> <cstdint> (C++11) <cstdlib> <exception> <initializer_list> (C++11)    <limits> <new> <source_location> (C++20) <stdfloat> (C++23) <typeinfo> <version> (C++20) 概念 <concepts> (C++20) 诊断 <cassert> <cerrno> <debugging> (C++26) <stacktrace> (C++23) <stdexcept> <system_error> (C++11) 内存管理 <memory> <memory_resource> (C++17) <scoped_allocator> (C++11) 元编程 <meta> (C++26) <ratio> (C++11) <type_traits> (C++11)

通用工具 <any> (C++17) <bitset> <bit> (C++20) <charconv> (C++17) <expected> (C++23) <format> (C++20) <functional> <optional> (C++17) <stdbit.h> (C++26) <tuple> (C++11) <typeindex> (C++11) <utility> <variant> (C++17) 容器 <array> (C++11) <deque> <flat_map> (C++23) <flat_set> (C++23) <forward_list> (C++11) <hive> (C++26) <inplace_vector> (C++26)    <list> <map> <mdspan> (C++23) <queue> <set> <span> (C++20) <stack> <unordered_map> (C++11) <unordered_set> (C++11) <vector> 迭代器 <iterator> 范围 <generator> (C++23) <ranges> (C++20)

算法 <algorithm> <numeric> 字符串 <cctype> <cstring> <cuchar> (C++11) <cwchar> <cwctype> <string_view> (C++17) <string> 文本处理 <clocale> <codecvt> (C++11/17/26*) <locale> <regex> (C++11) <text_encoding> (C++26)    cpp/header#数值库数值 <cfenv> (C++11) <cmath> <complex> <linalg> (C++26) <numbers> (C++20) <random> (C++11) <simd> (C++26) <stdckdint.h> (C++26) <valarray> 时间 <chrono> (C++11) <ctime> C 兼容性 <ccomplex> (C++11/17/20*) <ciso646> (C++20 前) <cstdalign> (C++11/17/20*) <cstdbool> (C++11/17/20*) <ctgmath> (C++11/17/20*)

输入/输出 <cinttypes> (C++11) <cstdio> <filesystem> (C++17) <fstream> <iomanip> <iosfwd> <iostream> <ios> <istream> <ostream> <print> (C++23) <spanstream> (C++23) <sstream> <streambuf> <strstream> (C++98/26*) <syncstream> (C++20) 并发支持 <atomic> (C++11) <barrier> (C++20) <condition_variable> (C++11) <future> (C++11) <hazard_pointer> (C++26) <latch> (C++20) <mutex> (C++11) <rcu> (C++26) <semaphore> (C++20) <shared_mutex> (C++14) <stdatomic.h> (C++23) <stop_token> (C++20) <thread> (C++11) 执行支持 <execution> (C++17)

 

此头文件是字符串库的一部分。

包含
<compare> (C++20)	三路比较运算符支持
<initializer_list> (C++11)	std::initializer_list 类模板
类
char_traits	描述字符类型的性质的类模板 (类模板)
std::char_traits<char>	(类模板特化)
std::char_traits<wchar_t>	(类模板特化)
std::char_traits<char8_t> (C++20)	(类模板特化)
std::char_traits<char16_t> (C++11)	(类模板特化)
std::char_traits<char32_t> (C++11)	(类模板特化)
basic_string	存储并操作字符序列 (类模板)
std::string	std::basic_string<char> (typedef)
std::u8string (C++20)	std::basic_string<char8_t> (typedef)
std::u16string (C++11)	std::basic_string<char16_t> (typedef)
std::u32string (C++11)	std::basic_string<char32_t> (typedef)
std::wstring	std::basic_string<wchar_t> (typedef)
std::pmr::basic_string (C++17)	(别名模板)
std::pmr::string (C++17)	std::pmr::basic_string<char> (typedef)
std::pmr::u8string (C++20)	std::pmr::basic_string<char8_t> (typedef)
std::pmr::u16string (C++17)	std::pmr::basic_string<char16_t> (typedef)
std::pmr::u32string (C++17)	std::pmr::basic_string<char32_t> (typedef)
std::pmr::wstring (C++17)	std::pmr::basic_string<wchar_t> (typedef)
std::hash<std::basic_string> (C++11)	字符串的散列支持 (类模板特化)
函数
operator+	连接两个字符串，一个字符串和一个 char，或者一个字符串和一个 std::string_view (函数模板)
operator==operator!=operator<operator>operator<=operator>=operator<=> (C++20 移除)(C++20 移除)(C++20 移除)(C++20 移除)(C++20 移除)(C++20)	以字典序比较两个字符串 (函数模板)
std::swap(std::basic_string)	特化 std::swap 算法 (函数模板)
erase(std::basic_string)erase_if(std::basic_string) (C++20)	擦除所有满足特定判别标准的元素 (函数模板)
输入/输出
operator<<operator>>	执行字符串的流输入与输出 (函数模板)
getline	从输入/输出流读取数据到字符串 (函数模板)
数值转换
stoistolstoll (C++11)(C++11)(C++11)	转换字符串为有符号整数 (函数)
stoulstoull (C++11)(C++11)	转换字符串为无符号整数 (函数)
stofstodstold (C++11)(C++11)(C++11)	转换字符串为浮点数 (函数)
to_string (C++11)	转换整数或浮点数为 string (函数)
to_wstring (C++11)	转换整数或浮点数为 wstring (函数)
范围访问
begincbegin (C++11)(C++14)	返回指向容器或数组起始的迭代器 (函数模板)
endcend (C++11)(C++14)	返回指向容器或数组结尾的迭代器 (函数模板)
rbegincrbegin (C++14)	返回指向一个容器或数组的逆向迭代器 (函数模板)
rendcrend (C++14)	返回容器或数组的逆向尾迭代器 (函数模板)
sizessize (C++17)(C++20)	返回容器或数组的大小 (函数模板)
empty (C++17)	检查容器是否为空 (函数模板)
data (C++17)	获得指向底层数组的指针 (函数模板)
字面量
在内联命名空间 std::literals::string_literals 定义
operator""s (C++14)	转换字符数组字面量为 basic_string (函数)

概要

#include <compare>
#include <initializer_list>

namespace std {
  // 字符特征
  template<class charT> struct char_traits; // 独立
  template<> struct char_traits<char>;      // 独立
  template<> struct char_traits<char8_t>;   // 独立
  template<> struct char_traits<char16_t>;  // 独立
  template<> struct char_traits<char32_t>;  // 独立
  template<> struct char_traits<wchar_t>;   // 独立

  // basic_string
  template<class CharT,
           class Traits = char_traits<CharT>,
           class Allocator = allocator<CharT>>
  class basic_string;

  template<class CharT, class Traits, class Allocator>
  constexpr 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>
  constexpr 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>
  constexpr 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>
  constexpr 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>
  constexpr basic_string<CharT, Traits, Allocator> operator+(
    const CharT* lhs, const basic_string<CharT, Traits, Allocator>& rhs);
  template<class CharT, class Traits, class Allocator>
  constexpr basic_string<CharT, Traits, Allocator> operator+(
    const CharT* lhs, basic_string<CharT, Traits, Allocator>&& rhs);
  template<class CharT, class Traits, class Allocator>
  constexpr basic_string<CharT, Traits, Allocator> operator+(
    CharT lhs, const basic_string<CharT, Traits, Allocator>& rhs);
  template<class CharT, class Traits, class Allocator>
  constexpr basic_string<CharT, Traits, Allocator> operator+(
    CharT lhs, basic_string<CharT, Traits, Allocator>&& rhs);
  template<class CharT, class Traits, class Allocator>
  constexpr basic_string<CharT, Traits, Allocator> operator+(
    const basic_string<CharT, Traits, Allocator>& lhs, const CharT* rhs);
  template<class CharT, class Traits, class Allocator>
  constexpr basic_string<CharT, Traits, Allocator> operator+(
    basic_string<CharT, Traits, Allocator>&& lhs, const CharT* rhs);
  template<class CharT, class Traits, class Allocator>
  constexpr basic_string<CharT, Traits, Allocator> operator+(
    const basic_string<CharT, Traits, Allocator>& lhs, CharT rhs);
  template<class CharT, class Traits, class Allocator>
  constexpr basic_string<CharT, Traits, Allocator> operator+(
    basic_string<CharT, Traits, Allocator>&& lhs, CharT rhs);
  template<class CharT, class Traits, class Allocator>
  constexpr basic_string<CharT, Traits, Allocator> operator+(
    const basic_string<CharT, Traits, Allocator>& lhs,
    type_identity_t<basic_string_view<CharT, Traits>> rhs);
  template<class CharT, class Traits, class Allocator>
  constexpr basic_string<CharT, Traits, Allocator> operator+(
    basic_string<CharT, Traits, Allocator>&& lhs,
    type_identity_t<basic_string_view<CharT, Traits>> rhs);
  template<class CharT, class Traits, class Allocator>
  constexpr basic_string<CharT, Traits, Allocator> operator+(
    type_identity_t<basic_string_view<CharT, Traits>> lhs,
    const basic_string<CharT, Traits, Allocator>& rhs);
  template<class CharT, class Traits, class Allocator>
  constexpr basic_string<CharT, Traits, Allocator> operator+(
    type_identity_t<basic_string_view<CharT, Traits>> lhs,
    basic_string<CharT, Traits, Allocator>&& rhs);

  template<class CharT, class Traits, class Allocator>
  constexpr bool operator==(const basic_string<CharT, Traits, Allocator>& lhs,
                            const basic_string<CharT, Traits, Allocator>& rhs) noexcept;
  template<class CharT, class Traits, class Allocator>
  constexpr bool operator==(const basic_string<CharT, Traits, Allocator>& lhs,
                            const CharT* rhs);

  template<class CharT, class Traits, class Allocator>
  constexpr /* 见描述 */ operator<=>(
    const basic_string<CharT, Traits, Allocator>& lhs,
    const basic_string<CharT, Traits, Allocator>& rhs) noexcept;
  template<class CharT, class Traits, class Allocator>
  constexpr /* 见描述 */ operator<=>(
    const basic_string<CharT, Traits, Allocator>& lhs, const CharT* rhs);

  // 交换
  template<class CharT, class Traits, class Allocator>
  constexpr void swap(
    basic_string<CharT, Traits, Allocator>& lhs,
    basic_string<CharT, Traits, Allocator>& rhs) noexcept(noexcept(lhs.swap(rhs)));

  // 插入器与提取器
  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);

  // 擦除
  template<class CharT, class Traits, class Allocator, class U = CharT>
  constexpr typename basic_string<CharT, Traits, Allocator>::size_type erase(
    basic_string<CharT, Traits, Allocator>& c, const U& value);
  template<class CharT, class Traits, class Allocator, class Predicate>
  constexpr typename basic_string<CharT, Traits, Allocator>::size_type erase_if(
    basic_string<CharT, Traits, Allocator>& c, Predicate pred);

  // basic_string typedef 名
  using string = basic_string<char>;
  using u8string = basic_string<char8_t>;
  using u16string = basic_string<char16_t>;
  using u32string = basic_string<char32_t>;
  using wstring = basic_string<wchar_t>;

  // 数值转换
  int stoi(const string& str, size_t* idx = nullptr, int base = 10);
  long stol(const string& str, size_t* idx = nullptr, int base = 10);
  unsigned long stoul(const string& str, size_t* idx = nullptr, int base = 10);
  long long stoll(const string& str, size_t* idx = nullptr, int base = 10);
  unsigned long long stoull(const string& str, size_t* idx = nullptr, int base = 10);
  float stof(const string& str, size_t* idx = nullptr);
  double stod(const string& str, size_t* idx = nullptr);
  long double stold(const string& str, size_t* idx = nullptr);
  constexpr string to_string(int val);
  constexpr string to_string(unsigned val);
  constexpr string to_string(long val);
  constexpr string to_string(unsigned long val);
  constexpr string to_string(long long val);
  constexpr 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 = nullptr, int base = 10);
  long stol(const wstring& str, size_t* idx = nullptr, int base = 10);
  unsigned long stoul(const wstring& str, size_t* idx = nullptr, int base = 10);
  long long stoll(const wstring& str, size_t* idx = nullptr, int base = 10);
  unsigned long long stoull(const wstring& str, size_t* idx = nullptr, int base = 10);
  float stof(const wstring& str, size_t* idx = nullptr);
  double stod(const wstring& str, size_t* idx = nullptr);
  long double stold(const wstring& str, size_t* idx = nullptr);
  constexpr wstring to_wstring(int val);
  constexpr wstring to_wstring(unsigned val);
  constexpr wstring to_wstring(long val);
  constexpr wstring to_wstring(unsigned long val);
  constexpr wstring to_wstring(long long val);
  constexpr wstring to_wstring(unsigned long long val);
  wstring to_wstring(float val);
  wstring to_wstring(double val);
  wstring to_wstring(long double val);

  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 u8string = basic_string<char8_t>;
    using u16string = basic_string<char16_t>;
    using u32string = basic_string<char32_t>;
    using wstring = basic_string<wchar_t>;
  }

  // 散列支持
  template<class T> struct hash;
  template<class A> struct hash<basic_string<char, char_traits<char>, A>>;
  template<class A> struct hash<basic_string<char8_t, char_traits<char8_t>, A>>;
  template<class A> struct hash<basic_string<char16_t, char_traits<char16_t>, A>>;
  template<class A> struct hash<basic_string<char32_t, char_traits<char32_t>, A>>;
  template<class A> struct hash<basic_string<wchar_t, char_traits<wchar_t>, A>>;

  inline namespace literals {
    inline namespace string_literals {
      // basic_string 字面量后缀
      constexpr string operator""s(const char* str, size_t len);
      constexpr u8string operator""s(const char8_t* str, size_t len);
      constexpr u16string operator""s(const char16_t* str, size_t len);
      constexpr u32string operator""s(const char32_t* str, size_t len);
      constexpr wstring operator""s(const wchar_t* str, size_t len);
    }
  }
}

类模板 std::char_traits

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;
    using comparison_category = strong_ordering;

    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 constexpr char_type* move(char_type* s1, const char_type* s2, size_t n);
    static constexpr char_type* copy(char_type* s1, const char_type* s2, size_t n);
    static constexpr 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;
  };

  template<> struct char_traits<char8_t>
  {
    using char_type = char8_t;
    using int_type = unsigned int;
    using off_type = streamoff;
    using pos_type = u8streampos;
    using state_type = mbstate_t;
    using comparison_category = strong_ordering;

    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 constexpr char_type* move(char_type* s1, const char_type* s2, size_t n);
    static constexpr char_type* copy(char_type* s1, const char_type* s2, size_t n);
    static constexpr 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;
  };

  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;
    using comparison_category = strong_ordering;

    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 constexpr char_type* move(char_type* s1, const char_type* s2, size_t n);
    static constexpr char_type* copy(char_type* s1, const char_type* s2, size_t n);
    static constexpr 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;
  };

  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;
    using comparison_category = strong_ordering;

    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 constexpr char_type* move(char_type* s1, const char_type* s2, size_t n);
    static constexpr char_type* copy(char_type* s1, const char_type* s2, size_t n);
    static constexpr 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;
  };

  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;
    using comparison_category = strong_ordering;

    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 constexpr char_type* move(char_type* s1, const char_type* s2, size_t n);
    static constexpr char_type* copy(char_type* s1, const char_type* s2, size_t n);
    static constexpr 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;
  };
}

类模板 std::basic_string

namespace std {
  template<class CharT,
           class Traits = char_traits<CharT>,
           class Allocator = allocator<CharT>>
  class basic_string
  {
  public:
    // 类型
    using traits_type = Traits;
    using value_type = CharT;
    using allocator_type = Allocator;
    using size_type = allocator_traits<Allocator>::size_type;
    using difference_type = allocator_traits<Allocator>::difference_type;
    using pointer = allocator_traits<Allocator>::pointer;
    using const_pointer = allocator_traits<Allocator>::const_pointer;
    using reference = value_type&;
    using const_reference = const value_type&;

    using iterator = /* 由实现定义 */;
    using const_iterator = /* 由实现定义 */;
    using reverse_iterator = std::reverse_iterator<iterator>;
    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
    static constexpr size_type npos = size_type(-1);

    // 构造/复制/销毁
    constexpr basic_string() noexcept(noexcept(Allocator()))
      : basic_string(Allocator())
    {
    }
    constexpr explicit basic_string(const Allocator& a) noexcept;
    constexpr basic_string(const basic_string& str);
    constexpr basic_string(basic_string&& str) noexcept;
    constexpr basic_string(const basic_string& str,
                           size_type pos,
                           const Allocator& a = Allocator());
    constexpr basic_string(const basic_string& str,
                           size_type pos,
                           size_type n,
                           const Allocator& a = Allocator());
    constexpr basic_string(basic_string&& str,
                           size_type pos,
                           const Allocator& a = Allocator());
    constexpr basic_string(basic_string&& str,
                           size_type pos,
                           size_type n,
                           const Allocator& a = Allocator());
    template<class T>
    constexpr basic_string(const T& t,
                           size_type pos,
                           size_type n,
                           const Allocator& a = Allocator());
    template<class T>
    constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
    constexpr basic_string(const CharT* s, size_type n, const Allocator& a = Allocator());
    constexpr basic_string(const CharT* s, const Allocator& a = Allocator());
    basic_string(nullptr_t) = delete;
    constexpr basic_string(size_type n, CharT c, const Allocator& a = Allocator());
    template<class InputIter>
    constexpr basic_string(InputIter begin,
                           InputIter end,
                           const Allocator& a = Allocator());
    template<container-compatible-range<CharT> R>
    constexpr basic_string(from_range_t, R&& rg, const Allocator& a = Allocator());
    constexpr basic_string(initializer_list<CharT>, const Allocator& = Allocator());
    constexpr basic_string(const basic_string&, const Allocator&);
    constexpr basic_string(basic_string&&, const Allocator&);
    constexpr ~basic_string();

    constexpr basic_string& operator=(const basic_string& str);
    constexpr basic_string& operator=(basic_string&& str) noexcept(
      allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
      allocator_traits<Allocator>::is_always_equal::value);
    template<class T> constexpr basic_string& operator=(const T& t);
    constexpr basic_string& operator=(const CharT* s);
    basic_string& operator=(nullptr_t) = delete;
    constexpr basic_string& operator=(CharT c);
    constexpr basic_string& operator=(initializer_list<CharT>);

    // 迭代器
    constexpr iterator begin() noexcept;
    constexpr const_iterator begin() const noexcept;
    constexpr iterator end() noexcept;
    constexpr const_iterator end() const noexcept;

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

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

    // 容量
    constexpr size_type size() const noexcept;
    constexpr size_type length() const noexcept;
    constexpr size_type max_size() const noexcept;
    constexpr void resize(size_type n, CharT c);
    constexpr void resize(size_type n);
    template<class Operation>
    constexpr void resize_and_overwrite(size_type n, Operation op);
    constexpr size_type capacity() const noexcept;
    constexpr void reserve(size_type res_arg);
    constexpr void shrink_to_fit();
    constexpr void clear() noexcept;
    constexpr bool empty() const noexcept;

    // 元素访问
    constexpr const_reference operator[](size_type pos) const;
    constexpr reference operator[](size_type pos);
    constexpr const_reference at(size_type n) const;
    constexpr reference at(size_type n);

    constexpr const_reference front() const;
    constexpr reference front();
    constexpr const_reference back() const;
    constexpr reference back();

    // 修改器
    constexpr basic_string& operator+=(const basic_string& str);
    template<class T> constexpr basic_string& operator+=(const T& t);
    constexpr basic_string& operator+=(const CharT* s);
    constexpr basic_string& operator+=(CharT c);
    constexpr basic_string& operator+=(initializer_list<CharT>);
    constexpr basic_string& append(const basic_string& str);
    constexpr basic_string& append(const basic_string& str,
                                   size_type pos,
                                   size_type n = npos);
    template<class T> constexpr basic_string& append(const T& t);
    template<class T>
    constexpr basic_string& append(const T& t, size_type pos, size_type n = npos);
    constexpr basic_string& append(const CharT* s, size_type n);
    constexpr basic_string& append(const CharT* s);
    constexpr basic_string& append(const CharT* s, size_type pos, size_type n);
    constexpr basic_string& append(size_type n, CharT c);
    template<class InputIter>
    constexpr basic_string& append(InputIter first, InputIter last);
    template<container-compatible-range<CharT> R>
    constexpr basic_string& append_range(R&& rg);
    constexpr basic_string& append(initializer_list<CharT>);

    constexpr void push_back(CharT c);

    constexpr basic_string& assign(const basic_string& str);
    constexpr basic_string& assign(basic_string&& str) noexcept(
      allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
      allocator_traits<Allocator>::is_always_equal::value);
    constexpr basic_string& assign(const basic_string& str,
                                   size_type pos,
                                   size_type n = npos);
    template<class T> constexpr basic_string& assign(const T& t);
    template<class T>
    constexpr basic_string& assign(const T& t, size_type pos, size_type n = npos);
    constexpr basic_string& assign(const CharT* s, size_type n);
    constexpr basic_string& assign(const CharT* s);
    constexpr basic_string& assign(const CharT* s, size_type pos, size_type n);
    constexpr basic_string& assign(size_type n, CharT c);
    template<class InputIter>
    constexpr basic_string& assign(InputIter first, InputIter last);
    template<container-compatible-range<CharT> R>
    constexpr basic_string& assign_range(R&& rg);
    constexpr basic_string& assign(initializer_list<CharT>);

    constexpr basic_string& insert(size_type pos, const basic_string& str);
    constexpr basic_string& insert(size_type pos1,
                                   const basic_string& str,
                                   size_type pos2,
                                   size_type n = npos);
    template<class T> constexpr basic_string& insert(size_type pos, const T& t);
    template<class T>
    constexpr basic_string& insert(size_type pos1,
                                   const T& t,
                                   size_type pos2,
                                   size_type n = npos);
    constexpr basic_string& insert(size_type pos, const CharT* s, size_type n);
    constexpr basic_string& insert(size_type pos, const CharT* s);
    constexpr basic_string& insert(size_type pos, size_type n, CharT c);
    constexpr iterator insert(const_iterator p, CharT c);
    constexpr iterator insert(const_iterator p, size_type n, CharT c);
    template<class InputIter>
    constexpr iterator insert(const_iterator p, InputIter first, InputIter last);
    template<container-compatible-range<CharT> R>
    constexpr iterator insert_range(const_iterator p, R&& rg);
    constexpr iterator insert(const_iterator p, initializer_list<CharT>);

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

    constexpr void pop_back();

    constexpr basic_string& replace(size_type pos1,
                                    size_type n1,
                                    const basic_string& str);
    constexpr basic_string& replace(size_type pos1,
                                    size_type n1,
                                    const basic_string& str,
                                    size_type pos2,
                                    size_type n2 = npos);
    template<class T>
    constexpr basic_string& replace(size_type pos1, size_type n1, const T& t);
    template<class T>
    constexpr basic_string& replace(
      size_type pos1, size_type n1, const T& t, size_type pos2, size_type n2 = npos);
    constexpr basic_string& replace(size_type pos,
                                    size_type n1,
                                    const CharT* s,
                                    size_type n2);
    constexpr basic_string& replace(size_type pos, size_type n1, const CharT* s);
    constexpr basic_string& replace(size_type pos, size_type n1, size_type n2, CharT c);
    constexpr basic_string& replace(const_iterator i1,
                                    const_iterator i2,
                                    const basic_string& str);
    template<class T>
    constexpr basic_string& replace(const_iterator i1, const_iterator i2, const T& t);
    constexpr basic_string& replace(const_iterator i1,
                                    const_iterator i2,
                                    const CharT* s,
                                    size_type n);
    constexpr basic_string& replace(const_iterator i1, const_iterator i2, const CharT* s);
    constexpr basic_string& replace(const_iterator i1,
                                    const_iterator i2,
                                    size_type n,
                                    CharT c);
    template<class InputIter>
    constexpr basic_string& replace(const_iterator i1,
                                    const_iterator i2,
                                    InputIter j1,
                                    InputIter j2);
    template<container-compatible-range<CharT> R>
    constexpr basic_string& replace_with_range(const_iterator i1,
                                               const_iterator i2,
                                               R&& rg);
    constexpr basic_string& replace(const_iterator,
                                    const_iterator,
                                    initializer_list<CharT>);

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

    constexpr void swap(basic_string& str) noexcept(
      allocator_traits<Allocator>::propagate_on_container_swap::value ||
      allocator_traits<Allocator>::is_always_equal::value);

    // 字符串操作
    constexpr const CharT* c_str() const noexcept;
    constexpr const CharT* data() const noexcept;
    constexpr CharT* data() noexcept;
    constexpr operator basic_string_view<CharT, Traits>() const noexcept;
    constexpr allocator_type get_allocator() const noexcept;

    template<class T>
    constexpr size_type find(const T& t, size_type pos = 0) const
      noexcept(/* 见描述 */);
    constexpr size_type find(const basic_string& str, 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 find(CharT c, size_type pos = 0) const noexcept;
    template<class T>
    constexpr size_type rfind(const T& t, size_type pos = npos) const
      noexcept(/* 见描述 */);
    constexpr size_type rfind(const basic_string& str,
                              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 rfind(CharT c, size_type pos = npos) const noexcept;

    template<class T>
    constexpr size_type find_first_of(const T& t, size_type pos = 0) const
      noexcept(/* 见描述 */);
    constexpr size_type find_first_of(const basic_string& str,
                                      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_first_of(CharT c, size_type pos = 0) const noexcept;
    template<class T>
    constexpr size_type find_last_of(const T& t, size_type pos = npos) const
      noexcept(/* 见描述 */);
    constexpr size_type find_last_of(const basic_string& str,
                                     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_last_of(CharT c, size_type pos = npos) const noexcept;

    template<class T>
    constexpr size_type find_first_not_of(const T& t, size_type pos = 0) const
      noexcept(/* 见描述 */);
    constexpr size_type find_first_not_of(const basic_string& str,
                                          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_first_not_of(CharT c, size_type pos = 0) const noexcept;
    template<class T>
    constexpr size_type find_last_not_of(const T& t, size_type pos = npos) const
      noexcept(/* 见描述 */);
    constexpr size_type find_last_not_of(const basic_string& str,
                                         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;
    constexpr size_type find_last_not_of(CharT c, size_type pos = npos) const noexcept;

    constexpr basic_string substr(size_type pos = 0, size_type n = npos) const&;
    constexpr basic_string substr(size_type pos = 0, size_type n = npos) &&;
    constexpr basic_string_view<CharT, Traits> subview(size_type pos = 0,
                                                       size_type n = npos) const;

    template<class T>
    constexpr int compare(const T& t) const noexcept(/* 见描述 */);
    template<class T>
    constexpr int compare(size_type pos1, size_type n1, const T& t) const;
    template<class T>
    constexpr int compare(size_type pos1,
                          size_type n1,
                          const T& t,
                          size_type pos2,
                          size_type n2 = npos) const;
    constexpr int compare(const basic_string& str) const noexcept;
    constexpr int compare(size_type pos1, size_type n1, const basic_string& str) const;
    constexpr int compare(size_type pos1,
                          size_type n1,
                          const basic_string& str,
                          size_type pos2,
                          size_type n2 = npos) 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 bool starts_with(basic_string_view<CharT, Traits> x) const noexcept;
    constexpr bool starts_with(CharT x) const noexcept;
    constexpr bool starts_with(const CharT* x) const;
    constexpr bool ends_with(basic_string_view<CharT, Traits> x) const noexcept;
    constexpr bool ends_with(CharT x) const noexcept;
    constexpr bool ends_with(const CharT* x) const;

    constexpr bool contains(basic_string_view<CharT, Traits> x) const noexcept;
    constexpr bool contains(CharT x) const noexcept;
    constexpr bool contains(const CharT* x) const;
  };

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

  template<ranges::input_range R, class Allocator = allocator<ranges::range_value_t<R>>>
  basic_string(from_range_t, R&&, Allocator = Allocator())
    -> basic_string<ranges::range_value_t<R>,
                    char_traits<ranges::range_value_t<R>>,
                    Allocator>;

  template<class CharT, class Traits, class Allocator = allocator<CharT>>
  explicit basic_string(basic_string_view<CharT, Traits>, const Allocator& = Allocator())
    -> basic_string<CharT, Traits, Allocator>;

  template<class CharT, class Traits, class Allocator = allocator<CharT>>
  basic_string(basic_string_view<CharT, Traits>,
               typename /* 见描述 */ ::size_type,
               typename /* 见描述 */ ::size_type,
               const Allocator& = Allocator()) -> basic_string<CharT, Traits, Allocator>;
}

缺陷报告

下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。

缺陷报告	应用于	出版时的行为	正确行为
LWG 209	C++98	概要中以下 std::basic_string 成员的声明使用的风格不统一： void push_back(CharT c); basic_string& assign(const basic_string& str); void swap(basic_string& str);	使之统一