直接初始化
来自cppreference.com
从明确的构造函数实参的集合初始化对象。
语法
T 对象 ( 实参 );
T 对象 |
(1) | ||||||||
T 对象 { 实参 };
|
(2) | (C++11 起) | |||||||
T ( 其他对象 )
T |
(3) | ||||||||
static_cast< T >( 其他对象 )
|
(4) | ||||||||
new T( 实参列表, ...)
|
(5) | ||||||||
类:: 类() : 成员( 实参列表, ...) { ... }
|
(6) | ||||||||
[ 实参](){ ... }
|
(7) | (C++11 起) | |||||||
解释
在下列场合进行直接初始化:
1) 以表达式或花括号初始化器列表 (C++11 起)的非空带括号列表初始化
2) 以花括号环绕的单个初始化器初始化一个非类类型对象(注意:对于类类型和其他使用花括号初始化器列表的初始化,见列表初始化)
5) 用带有非空初始化器的 new 表达式初始化具有动态存储期的对象
6) 用构造函数初始化器列表初始化基类或非静态成员
7) 在 lambda 表达式中从按复制捕获的变量初始化闭包对象的成员
直接初始化的效果是:
- 如果
T
是数组类型,那么
|
(C++20 前) |
struct A { explicit A(int i = 0) {} }; A a[2](A(1)); // OK:以 A(1) 初始化 a[0] 并以 A() 初始化 a[1] A b[2]{A(1)}; // 错误:从 {} 隐式复制初始化 b[1] 选择了 explicit 构造函数 |
(C++20 起) |
- 如果
T
是类类型,
(C++17 起) |
- 检验
T
的构造函数并由重载决议选取最佳匹配。然后调用该构造函数初始化对象。
- 检验
struct B { int a; int&& r; }; int f(); int n = 10; B b1{1, f()}; // OK:延长生存期 B b2(1, f()); // 良构,但有悬垂引用 B b3{1.0, 1}; // 错误:窄化转换 B b4(1.0, 1); // 良构,但有悬垂引用 B b5(1.0, std::move(n)); // OK |
(C++20 起) |
- 否则,如果
T
是非类类型但源类型是类类型,则检验源类型及其各基类的转换函数,并由重载决议选取最佳匹配。然后用选取的用户定义转换,转换初始化器表达式为所初始化的对象。 - 否则,如果
T
是 bool 而原类型是 std::nullptr_t,则被初始化对象的值为 false。 - 否则,在必要时使用标准转换,转换 其他对象 的值为
T
的无 cv 限定版本,而所初始化的对象的初值为(可能为转换后的)该值。
注解
直接初始比复制初始化更宽松:复制初始化仅考虑非 explicit 构造函数和非 explicit 的用户定义转换函数,而直接初始化考虑所有构造函数和所有用户定义转换函数。
在使用直接初始化语法 (1)(带圆括号)的变量声明和函数声明之间有歧义的情况下,编译器始终选择函数声明。此消歧义规则有时是反直觉的,并且已被称为最烦人的分析。
#include <iterator> #include <string> #include <fstream> int main() { std::ifstream file("data.txt"); // 下面是函数声明: std::string str(std::istreambuf_iterator<char>(file), std::istreambuf_iterator<char>()); // 它声明名为 str 的函数,其返回类型为 std::string, // 第一参数拥有 std::istreambuf_iterator<char> 类型和名称 "file" // 第二参数无名称并拥有类型 std::istreambuf_iterator<char>(), // 它被重写成函数指针类型 std::istreambuf_iterator<char>(*)() // C++11 前的修正:用额外括号环绕其中一个实参 std::string str( (std::istreambuf_iterator<char>(file) ), std::istreambuf_iterator<char>()); // C++11 后的修正:列表初始化任意实参 std::string str(std::istreambuf_iterator<char>{file}, {}); }
类似地,在以函数式转型表达式 (3) 为其最左子表达式的表达式语句,和声明语句间有歧义的情况下,以将它当做声明解决歧义。此消歧义是纯语法的:它不考虑语句中出现的名字除了是否为类型名之外的含义。
struct M { }; struct L { L(M&); }; M n; void f() { M(m); // 声明,等价于 M m; L(n); // 非良构的声明 L(l)(m); // 仍然是声明 }
示例
运行此代码
#include <string> #include <iostream> #include <memory> struct Foo { int mem; explicit Foo(int n) : mem(n) {} }; int main() { std::string s1("test"); // 自 const char* 的构造函数 std::string s2(10, 'a'); std::unique_ptr<int> p(new int(1)); // OK:允许 explicit 构造函数 // std::unique_ptr<int> p = new int(1); // 错误:构造函数为 explicit Foo f(2); // f 被直接初始化: // 构造函数形参 n 从右值 2 复制初始化 // f.mem 从形参 n 直接初始化 // Foo f2 = 2; // 错误:构造函数为 explicit std::cout << s1 << ' ' << s2 << ' ' << *p << ' ' << f.mem << '\n'; }
输出:
test aaaaaaaaaa 1 2