标准库标头 <string>

 

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) 元编程 <type_traits>(C++11) <ratio>(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，或者一个字符串和一个 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_stringtemplate<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>constexprbool operator==(const basic_string<CharT, Traits, Allocator>& lhs, const basic_string<CharT, Traits, Allocator>& rhs)noexcept;template<class CharT, class Traits, class Allocator>constexprbool 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>constexprvoid 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>constexprtypename 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 Pred>constexprtypename basic_string<CharT, Traits, Allocator>::size_type erase_if(basic_string<CharT, Traits, Allocator>& c, Pred 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);unsignedlong stoul(const string& str, size_t* idx = nullptr, int base =10);longlong stoll(const string& str, size_t* idx = nullptr, int base =10);unsignedlonglong 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);longdouble stold(const string& str, size_t* idx = nullptr); string to_string(int val); string to_string(unsigned val); string to_string(long val); string to_string(unsignedlong val); string to_string(longlong val); string to_string(unsignedlonglong val); string to_string(float val); string to_string(double val); string to_string(longdouble 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);unsignedlong stoul(const wstring& str, size_t* idx = nullptr, int base =10);longlong stoll(const wstring& str, size_t* idx = nullptr, int base =10);unsignedlonglong 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);longdouble stold(const wstring& str, size_t* idx = nullptr); wstring to_wstring(int val); wstring to_wstring(unsigned val); wstring to_wstring(long val); wstring to_wstring(unsignedlong val); wstring to_wstring(longlong val); wstring to_wstring(unsignedlonglong val); wstring to_wstring(float val); wstring to_wstring(double val); wstring to_wstring(longdouble 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>>;   inlinenamespace literals {inlinenamespace string_literals {// basic_string 字面量后缀constexpr string operator""s(constchar* str, size_t len);constexpr u8string operator""s(const char8_t* str, size_t len);constexpr u16string operator""s(constchar16_t* str, size_t len);constexpr u32string operator""s(constchar32_t* str, size_t len);constexpr wstring operator""s(constwchar_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;   staticconstexprvoid assign(char_type& c1, const char_type& c2)noexcept;staticconstexprbool eq(char_type c1, char_type c2)noexcept;staticconstexprbool lt(char_type c1, char_type c2)noexcept;   staticconstexprint compare(const char_type* s1, const char_type* s2, size_t n);staticconstexpr size_t length(const char_type* s);staticconstexprconst char_type* find(const char_type* s, size_t n, const char_type& a);staticconstexpr char_type* move(char_type* s1, const char_type* s2, size_t n);staticconstexpr char_type* copy(char_type* s1, const char_type* s2, size_t n);staticconstexpr char_type* assign(char_type* s, size_t n, char_type a);   staticconstexpr int_type not_eof(int_type c)noexcept;staticconstexpr char_type to_char_type(int_type c)noexcept;staticconstexpr int_type to_int_type(char_type c)noexcept;staticconstexprbool eq_int_type(int_type c1, int_type c2)noexcept;staticconstexpr int_type eof()noexcept;};   template<>struct char_traits<char8_t>{using char_type = char8_t;using int_type =unsignedint;using off_type = streamoff;using pos_type = u8streampos;using state_type = mbstate_t;using comparison_category = strong_ordering;   staticconstexprvoid assign(char_type& c1, const char_type& c2)noexcept;staticconstexprbool eq(char_type c1, char_type c2)noexcept;staticconstexprbool lt(char_type c1, char_type c2)noexcept;   staticconstexprint compare(const char_type* s1, const char_type* s2, size_t n);staticconstexpr size_t length(const char_type* s);staticconstexprconst char_type* find(const char_type* s, size_t n, const char_type& a);staticconstexpr char_type* move(char_type* s1, const char_type* s2, size_t n);staticconstexpr char_type* copy(char_type* s1, const char_type* s2, size_t n);staticconstexpr char_type* assign(char_type* s, size_t n, char_type a);staticconstexpr int_type not_eof(int_type c)noexcept;staticconstexpr char_type to_char_type(int_type c)noexcept;staticconstexpr int_type to_int_type(char_type c)noexcept;staticconstexprbool eq_int_type(int_type c1, int_type c2)noexcept;staticconstexpr 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;   staticconstexprvoid assign(char_type& c1, const char_type& c2)noexcept;staticconstexprbool eq(char_type c1, char_type c2)noexcept;staticconstexprbool lt(char_type c1, char_type c2)noexcept;   staticconstexprint compare(const char_type* s1, const char_type* s2, size_t n);staticconstexpr size_t length(const char_type* s);staticconstexprconst char_type* find(const char_type* s, size_t n, const char_type& a);staticconstexpr char_type* move(char_type* s1, const char_type* s2, size_t n);staticconstexpr char_type* copy(char_type* s1, const char_type* s2, size_t n);staticconstexpr char_type* assign(char_type* s, size_t n, char_type a);   staticconstexpr int_type not_eof(int_type c)noexcept;staticconstexpr char_type to_char_type(int_type c)noexcept;staticconstexpr int_type to_int_type(char_type c)noexcept;staticconstexprbool eq_int_type(int_type c1, int_type c2)noexcept;staticconstexpr 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;   staticconstexprvoid assign(char_type& c1, const char_type& c2)noexcept;staticconstexprbool eq(char_type c1, char_type c2)noexcept;staticconstexprbool lt(char_type c1, char_type c2)noexcept;   staticconstexprint compare(const char_type* s1, const char_type* s2, size_t n);staticconstexpr size_t length(const char_type* s);staticconstexprconst char_type* find(const char_type* s, size_t n, const char_type& a);staticconstexpr char_type* move(char_type* s1, const char_type* s2, size_t n);staticconstexpr char_type* copy(char_type* s1, const char_type* s2, size_t n);staticconstexpr char_type* assign(char_type* s, size_t n, char_type a);   staticconstexpr int_type not_eof(int_type c)noexcept;staticconstexpr char_type to_char_type(int_type c)noexcept;staticconstexpr int_type to_int_type(char_type c)noexcept;staticconstexprbool eq_int_type(int_type c1, int_type c2)noexcept;staticconstexpr 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;   staticconstexprvoid assign(char_type& c1, const char_type& c2)noexcept;staticconstexprbool eq(char_type c1, char_type c2)noexcept;staticconstexprbool lt(char_type c1, char_type c2)noexcept;   staticconstexprint compare(const char_type* s1, const char_type* s2, size_t n);staticconstexpr size_t length(const char_type* s);staticconstexprconst char_type* find(const char_type* s, size_t n, const char_type& a);staticconstexpr char_type* move(char_type* s1, const char_type* s2, size_t n);staticconstexpr char_type* copy(char_type* s1, const char_type* s2, size_t n);staticconstexpr char_type* assign(char_type* s, size_t n, char_type a);   staticconstexpr int_type not_eof(int_type c)noexcept;staticconstexpr char_type to_char_type(int_type c)noexcept;staticconstexpr int_type to_int_type(char_type c)noexcept;staticconstexprbool eq_int_type(int_type c1, int_type c2)noexcept;staticconstexpr 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 =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 =/* 由实现定义 */;using const_iterator =/* 由实现定义 */;using reverse_iterator =std::reverse_iterator<iterator>;using const_reverse_iterator =std::reverse_iterator<const_iterator>;staticconstexpr size_type npos = size_type(-1);   // 构造/复制/销毁constexpr basic_string()noexcept(noexcept(Allocator())): basic_string(Allocator()){}constexprexplicit 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>constexprexplicit 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 InputIt>constexpr basic_string(InputIt begin, InputIt 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()constnoexcept;constexpr iterator end()noexcept;constexpr const_iterator end()constnoexcept;   constexpr reverse_iterator rbegin()noexcept;constexpr const_reverse_iterator rbegin()constnoexcept;constexpr reverse_iterator rend()noexcept;constexpr const_reverse_iterator rend()constnoexcept;   constexpr const_iterator cbegin()constnoexcept;constexpr const_iterator cend()constnoexcept;constexpr const_reverse_iterator crbegin()constnoexcept;constexpr const_reverse_iterator crend()constnoexcept;   // 容量constexpr size_type size()constnoexcept;constexpr size_type length()constnoexcept;constexpr size_type max_size()constnoexcept;constexprvoid resize(size_type n, CharT c);constexprvoid resize(size_type n);template<class Operation>constexprvoid resize_and_overwrite(size_type n, Operation op);constexpr size_type capacity()constnoexcept;constexprvoid reserve(size_type res_arg);constexprvoid shrink_to_fit();constexprvoid clear()noexcept;constexprbool empty()constnoexcept;   // 元素访问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);   constexprconst CharT& front()const;constexpr CharT& front();constexprconst CharT& back()const;constexpr CharT& 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(size_type n, CharT c);template<class InputIt>constexpr basic_string& append(InputIt first, InputIt last);template<container-compatible-range<CharT> R>constexpr basic_string& append_range(R&& rg);constexpr basic_string& append(initializer_list<CharT>);   constexprvoid 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(size_type n, CharT c);template<class InputIt>constexpr basic_string& assign(InputIt first, InputIt 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 InputIt>constexpr iterator insert(const_iterator p, InputIt first, InputIt 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);   constexprvoid 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 InputIt>constexpr basic_string& replace(const_iterator i1, const_iterator i2, InputIt j1, InputIt 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;   constexprvoid swap(basic_string& str)noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value|| allocator_traits<Allocator>::is_always_equal::value);   // 字符串操作constexprconst CharT* c_str()constnoexcept;constexprconst CharT* data()constnoexcept;constexpr CharT* data()noexcept;constexpr operator basic_string_view<CharT, Traits>()constnoexcept;constexpr allocator_type get_allocator()constnoexcept;   template<class T>constexpr size_type find(const T& t, size_type pos =0)constnoexcept(/* 见描述 */);constexpr size_type find(const basic_string& str, size_type pos =0)constnoexcept;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)constnoexcept;template<class T>constexpr size_type rfind(const T& t, size_type pos = npos)constnoexcept(/* 见描述 */);constexpr size_type rfind(const basic_string& str, size_type pos = npos)constnoexcept;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)constnoexcept;   template<class T>constexpr size_type find_first_of(const T& t, size_type pos =0)constnoexcept(/* 见描述 */);constexpr size_type find_first_of(const basic_string& str, size_type pos =0)constnoexcept;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)constnoexcept;template<class T>constexpr size_type find_last_of(const T& t, size_type pos = npos)constnoexcept(/* 见描述 */);constexpr size_type find_last_of(const basic_string& str, size_type pos = npos)constnoexcept;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)constnoexcept;   template<class T>constexpr size_type find_first_not_of(const T& t, size_type pos =0)constnoexcept(/* 见描述 */);constexpr size_type find_first_not_of(const basic_string& str, size_type pos =0)constnoexcept;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)constnoexcept;template<class T>constexpr size_type find_last_not_of(const T& t, size_type pos = npos)constnoexcept(/* 见描述 */);constexpr size_type find_last_not_of(const basic_string& str, size_type pos = npos)constnoexcept;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)constnoexcept;   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)&&;   template<class T>constexprint compare(const T& t)constnoexcept(/* 见描述 */);template<class T>constexprint compare(size_type pos1, size_type n1, const T& t)const;template<class T>constexprint compare(size_type pos1, size_type n1, const T& t, size_type pos2, size_type n2 = npos)const;constexprint compare(const basic_string& str)constnoexcept;constexprint compare(size_type pos1, size_type n1, const basic_string& str)const;constexprint compare(size_type pos1, size_type n1, const basic_string& str, size_type pos2, size_type n2 = npos)const;constexprint compare(const CharT* s)const;constexprint compare(size_type pos1, size_type n1, const CharT* s)const;constexprint compare(size_type pos1, size_type n1, const CharT* s, size_type n2)const;   constexprbool starts_with(basic_string_view<CharT, Traits> x)constnoexcept;constexprbool starts_with(CharT x)constnoexcept;constexprbool starts_with(const CharT* x)const;constexprbool ends_with(basic_string_view<CharT, Traits> x)constnoexcept;constexprbool ends_with(CharT x)constnoexcept;constexprbool ends_with(const CharT* x)const;   constexprbool contains(basic_string_view<CharT, Traits> x)constnoexcept;constexprbool contains(CharT x)constnoexcept;constexprbool contains(const CharT* x)const;};   template<class InputIt, class Allocator = allocator<typename iterator_traits<InputIt>::value_type>> basic_string(InputIt, InputIt, Allocator = Allocator())-> basic_string<typename iterator_traits<InputIt>::value_type, char_traits<typename iterator_traits<InputIt>::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);	使之统一