std::basic_string<CharT,Traits,Allocator>::basic_string

	(1)
basic_string() : basic_string(Allocator()) {}			(C++11 起) (C++17 前)
basic_string() noexcept(noexcept(Allocator())) : basic_string(Allocator()) {}			(C++17 起) (C++20 起为 constexpr)
		(2)
explicit basic_string( const Allocator& alloc = Allocator() );				(C++11 前)
explicit basic_string( const Allocator& alloc );				(noexcept since C++17) (C++20 起为 constexpr)
basic_string( size_type count, CharT ch, const Allocator& alloc = Allocator() );			(3)	(C++20 起为 constexpr)
template< class InputIt > basic_string( InputIt first, InputIt last, const Allocator& alloc = Allocator() );			(4)	(C++20 起为 constexpr)
template< container-compatible-range<CharT> R > constexpr basic_string( std::from_range_t, R&& rg, const Allocator& = Allocator());			(5)	(C++23 起)
basic_string( const CharT* s, size_type count, const Allocator& alloc = Allocator() );			(6)	(C++20 起为 constexpr)
basic_string( const CharT* s, const Allocator& alloc = Allocator() );			(7)	(C++20 起为 constexpr)
basic_string( std::nullptr_t ) = delete;			(8)	(C++23 起)
template< class StringViewLike > explicit basic_string( const StringViewLike& t, const Allocator& alloc = Allocator() );			(9)	(C++17 起) (C++20 起为 constexpr)
template< class StringViewLike > basic_string( const StringViewLike& t, size_type pos, size_type count, const Allocator& alloc = Allocator());			(10)	(C++17 起)
basic_string( const basic_string& other );			(11)	(C++20 起为 constexpr)
basic_string( basic_string&& other ) noexcept;			(12)	(C++11 起) (C++20 起为 constexpr)
basic_string( const basic_string& other, const Allocator& alloc );			(13)	(C++11 起) (C++20 起为 constexpr)
basic_string( basic_string&& other, const Allocator& alloc );			(14)	(C++11 起) (C++20 起为 constexpr)
basic_string( const basic_string& other, size_type pos, const Allocator& alloc = Allocator() );			(15)	(C++20 起为 constexpr)
constexpr basic_string( basic_string&& other, size_type pos, const Allocator& alloc = Allocator());			(16)	(C++23 起)
basic_string( const basic_string& other, size_type pos, size_type count, const Allocator& alloc = Allocator() );			(17)	(C++20 起为 constexpr)
constexpr basic_string( basic_string&& other, size_type pos, size_type count, const Allocator& alloc = Allocator());			(18)	(C++23 起)
basic_string( std::initializer_list<CharT> ilist, const Allocator& alloc = Allocator() );			(19)	(C++11 起) (C++20 起为 constexpr)

构造新字符串，数据源多样，可选使用用户提供的分配器 alloc。

1) 自 C++11 起的默认构造函数。构造一个空字符串，使用默认构造的分配器。

如果 Allocator 不满足 DefaultConstructible 的要求，则行为未定义。

2) C++11 之前的默认构造函数。构造一个空字符串，使用给定的分配器 alloc。

3) 构造一个包含 count 个字符 ch 副本的字符串。

如果 `CharT` 不能 CopyInsertable 到 std::basic_string<CharT> 中，则行为未定义。	(C++11 起)
此重载仅在 `Allocator` 满足 Allocator 的要求时才参与重载决议。	(C++17 起)

4) 构造一个包含范围 [first, last) 内容的字符串。范围 [first, last) 中的每个迭代器都恰好解引用一次。

如果 InputIt 不满足 LegacyInputIterator 的要求，则会调用重载 (3)，参数为 static_cast<size_type>(first)、last 和 alloc。

(C++11 前)

此重载仅在 InputIt 满足 LegacyInputIterator 的要求时才参与重载决议。

如果 CharT 不能从 *first EmplaceConstructible 到 std::basic_string<CharT> 中，则行为未定义。

(C++11 起)

5) 构造一个包含范围 rg 内容的字符串。范围 rg 中的每个迭代器都恰好解引用一次。

如果 CharT 不能从 *ranges::begin(rg) EmplaceConstructible 到 std::basic_string<CharT> 中，则行为未定义。

6) 构造一个包含范围 [s, s + count) 内容的字符串。

如果 [s, s + count) 不是有效范围，则行为未定义。

7) 等价于 basic_string(s, Traits::length(s), alloc)。

此重载仅在 Allocator 满足 Allocator 的要求时才参与重载决议。

(C++17 起)

8) std::basic_string 不能从 nullptr 构造。

9) 隐式将 t 转换为字符串视图 sv，如同通过 std::basic_string_view<CharT, Traits> sv = t;，然后构造一个字符串，如同通过 basic_string(sv.data(), sv.size(), alloc)。

此重载仅在 std::is_convertible_v<const StringViewLike&,
std::basic_string_view<CharT, Traits>> 为 true 且 std::is_convertible_v<const StringViewLike&, const CharT*> 为 false 时才参与重载决议。

10) 隐式将 t 转换为字符串视图 sv，如同通过 std::basic_string_view<CharT, Traits> sv = t;，然后构造一个字符串，如同通过 basic_string(sv.substr(pos, n), alloc)。

此重载仅在 std::is_convertible_v<const StringViewLike&,
std::basic_string_view<CharT, Traits>> 为 true 时才参与重载决议。

11-18) 构造一个包含 other 部分内容的字符串。如果 other 的类型是 basic_string&&，则构造完成后，other 处于有效但未指定的状态。

11) 复制构造函数。

分配器如同通过调用 std::allocator_traits<Allocator>::
select_on_container_copy_construction
(other.get_allocator()) 获得。

(C++11 起)

12) 移动构造函数。分配器通过从 other.get_allocator() 移动构造获得。

13) 与复制构造函数相同，但使用 alloc 作为分配器。

如果 CharT 不能 CopyInsertable 到 std::basic_string<CharT> 中，则行为未定义。

14) 与移动构造函数相同，但使用 alloc 作为分配器。

如果 CharT 不能 MoveInsertable 到 std::basic_string<CharT> 中，则行为未定义。

15,16) 构造一个包含范围 [other.data() + pos, other.data() + other.size()) 内容的字符串。

17,18) 构造一个包含范围 [other.data() + pos, other.data() + (pos + std::min(count, other.size() - pos))) 内容的字符串。

19) 等价于 basic_string(ilist.begin(), ilist.end())。

alloc	-	用于此字符串所有内存分配的分配器
count	-	结果字符串的大小
ch	-	初始化字符串的值
pos	-	要包含的第一个字符的位置
first, last	-	从中复制字符的范围
s	-	指向字符数组的指针，用作初始化字符串的源
其他	-	另一个字符串，用作初始化字符串的源
ilist	-	用于初始化字符串的 std::initializer_list
t	-	可转换为 std::basic_string_view 的对象，用于初始化字符串
rg	-	一个与容器兼容的范围

[编辑] 复杂度

1,2) 常数时间。

3-7) 字符串大小的线性复杂度。

9-11) 字符串大小的线性复杂度。

12) 常数复杂度。

13) 字符串大小的线性复杂度。

14) 如果 alloc != other.get_allocator() 为 true，则为字符串大小的线性复杂度，否则为常数复杂度。

15-19) 字符串大小的线性复杂度。

[编辑] 异常

10) 如果 pos 超出范围，则抛出 std::out_of_range。

14) 如果 alloc == str.get_allocator() 为 true，则不抛出任何异常。

15-18) 如果 pos > other.size() 为 true，则抛出 std::out_of_range。

如果构造的字符串长度会超过 max_size()（例如，对于 (3)，如果 count > max_size()），则抛出 std::length_error。对 Allocator::allocate 的调用可能会抛出异常。

如果因任何原因抛出异常，这些函数没有效果（强异常安全保证）。

[编辑] 注意

使用包含嵌入 '\0' 字符的字符串字面量初始化时，会使用重载 (7)，它会在第一个空字符处停止。这可以通过指定不同的构造函数或使用 operator""s 来避免。

std::string s1 = "ab\0\0cd";   // s1 contains "ab"
std::string s2{"ab\0\0cd", 6}; // s2 contains "ab\0\0cd"
std::string s3 = "ab\0\0cd"s;  // s3 contains "ab\0\0cd"

特性测试宏	值	标准	特性
`__cpp_lib_containers_ranges`	`202202L`	(C++23)	标记构造函数 (5) 以从容器兼容范围构造

[编辑] 示例

运行此代码

#include <cassert>
#include <cctype>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <string>
 
int main()
{
    std::cout << "1)  string(); ";
    std::string s1;
    assert(s1.empty() && (s1.length() == 0) && (s1.size() == 0));
    std::cout << "s1.capacity(): " << s1.capacity() << '\n'; // unspecified
 
    std::cout << "3)  string(size_type count, CharT ch): ";
    std::string s2(4, '=');
    std::cout << std::quoted(s2) << '\n'; // "===="
 
    std::cout << "4)  string(InputIt first, InputIt last): ";
    char mutable_c_str[] = "another C-style string";
    std::string s4(std::begin(mutable_c_str) + 8, std::end(mutable_c_str) - 1);
    std::cout << std::quoted(s4) << '\n'; // "C-style string"
 
    std::cout << "6)  string(CharT const* s, size_type count): ";
    std::string s6("C-style string", 7);
    std::cout << std::quoted(s6) << '\n'; // "C-style", i.e. [0, 7)
 
    std::cout << "7)  string(CharT const* s): ";
    std::string s7("C-style\0string");
    std::cout << std::quoted(s7) << '\n'; // "C-style"
 
    std::cout << "11) string(string&): ";
    std::string const other11("Exemplar");
    std::string s11(other11);
    std::cout << std::quoted(s11) << '\n'; // "Exemplar"
 
    std::cout << "12) string(string&&): ";
    std::string s12(std::string("C++ by ") + std::string("example"));
    std::cout << std::quoted(s12) << '\n'; // "C++ by example"
 
    std::cout << "15) string(const string& other, size_type pos): ";
    std::string const other15("Mutatis Mutandis");
    std::string s15(other15, 8);
    std::cout << std::quoted(s15) << '\n'; // "Mutandis", i.e. [8, 16)
 
    std::cout << "17) string(const string& other, size_type pos, size_type count): ";
    std::string const other17("Exemplary");
    std::string s17(other17, 0, other17.length() - 1);
    std::cout << std::quoted(s17) << '\n'; // "Exemplar"
 
    std::cout << "19) string(std::initializer_list<CharT>): ";
    std::string s19({'C', '-', 's', 't', 'y', 'l', 'e'});
    std::cout << std::quoted(s19) << '\n'; // "C-style"
}

可能的输出

1)  string(); s1.capacity(): 15
3)  string(size_type count, CharT ch): "===="
4)  string(InputIt first, InputIt last): "C-style string"
6)  string(CharT const* s, size_type count): "C-style"
7)  string(CharT const* s): "C-style"
11) string(string&): "Exemplar"
12) string(string&&): "C++ by example"
15) string(const string& other, size_type pos): "Mutandis"
17) string(const string& other, size_type pos, size_type count): "Exemplar"
19) string(std::initializer_list<CharT>): "C-style"

[编辑] 缺陷报告

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

缺陷报告	应用于	发布时的行为	正确的行为
LWG 301	C++98	重载 (4) 没有使用参数如果 `InputIt` 是整型，则使用参数 alloc	使用该参数
LWG 438	C++98	重载 (4) 只会调用重载 (3) 是整数类型时调用重载 (4)	如果 `InputIt` 则调用重载 (3) 不是 LegacyInputIterator
LWG 847	C++98	没有异常安全保证	添加了强异常安全保证
LWG 2193	C++11	默认构造函数是显式的	已改为非 explicit
LWG 2235	C++98	s 可能是空指针值	在这种情况下行为未定义
LWG 2250	C++98	如果 pos > other.size() 为 true，则重载 (17) 的行为未定义如果 pos > other.size() 为 true	在这种情况下总是抛出异常
LWG 2583	C++98	重载 (17) 无法提供分配器	添加了重载 (15)
LWG 2946	C++17	重载 (9) 在某些情况下会导致歧义	通过使其成为模板来避免
LWG 3076	C++17	重载 (3,7) 可能导致类模板参数推导中的歧义在类模板参数推导中	已受约束
LWG 3111 (P1148R0)	C++98	LWG issue 2235 的解决方案使得 basic_string(nullptr, 0) 的行为未定义行为明确	在这种情况下定义^[1] 在这种情况下定义

↑ [nullptr, nullptr + 0) 是一个有效的空范围，因为将零添加到空指针值也是明确定义的（结果仍然是空指针值）。

[编辑] 另见

assign	给字符串赋值字符 (public member function) [编辑]
operator=	给字符串赋值 (public member function) [编辑]
to_string (C++11)	将整数或浮点值转换为 `string` (function) [编辑]
to_wstring (C++11)	将整数或浮点值转换为 `wstring` (function) [编辑]
(构造函数)	构造 `basic_string_view` (public member function of `std::basic_string_view<CharT,Traits>`) [编辑]

[1] [nullptr, nullptr + 0) 是一个有效的空范围，因为将零添加到空指针值也是明确定义的（结果仍然是空指针值）。

[1]

编译器支持
自由（freestanding）与宿主（hosted）
语言
标准库
标准库头文件
具名要求
特性测试宏 (C++20)
语言支持库
概念库 (C++20)
诊断库
内存管理库
元编程库 (C++11)
通用工具库
容器库
迭代器库
范围库 (C++20)
算法库
字符串库
文本处理库
数值库
日期和时间库
输入/输出库
文件系统库 (C++17)
并发支持库 (C++11)
执行控制库 (C++26)
技术规范
符号索引
外部库

cppreference.cn

命名空间

变体

视图

操作