直接初始化

< cpp‎ | language
 
C++
 
C++ 语言
 
初始化
 

从明确的构造函数实参的集合初始化对象。

语法

T object ( arg );

T object ( arg1, arg2, ... );

(1)
T object { arg }; (2) (C++11 起)
T ( other )

T ( arg1, arg2, ... )

(3)
static_cast< T >( other ) (4)
new T(args, ...) (5)
Class::Class() : member(args, ...) { ... } (6)
[arg](){ ... } (7) (C++11 起)

解释

在下列场合进行直接初始化：

1) 以表达式或花括号初始化器列表 (C++11 起)的非空带括号列表初始化
2) 作为列表初始化的一部分，以花括号环绕的单个初始化器初始化非类类型和非数组类型对象时，以初始化提供了初始化器的元素（注意：对于类类型和其他使用花括号初始化器列表的初始化，见列表初始化）
3) 用函数式转型或以带括号的表达式列表初始化纯右值临时量 (C++17 前)纯右值的结果对象 (C++17 起)
4) 用 static_cast 表达式初始化纯右值临时量 (C++17 前)纯右值的结果对象 (C++17 起)
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 是类类型，
  • 若初始化器为纯右值表达式，而其类型与 T 为相同的类（忽略 cv 限定），则用初始化器表达式自身，而非从它实质化的临时量，初始化目标对象：
    （ C++17 前，编译器可以在此情况下消除源自纯右值的构造，但适合的构造函数必须仍可访问：参阅复制消除）
(C++17 起)
  • 检验 T 的构造函数并由重载决议选取最佳匹配。然后调用该构造函数初始化对象。
  • 否则，若目标类型是（可能有 cv 限定）的聚合类，则按聚合初始化中所述进行初始化，但允许窄化转换，不允许指派初始化器，不延长引用所绑定到的临时量的生存期，不进行花括号消除，并值初始化任何无初始化器的元素。 
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。
  • 否则，使用标准转换（若有必要），转换 other 的值为 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

参阅