列表初始化 (C++11 起)

来自cppreference.com
< cpp‎ | language

从花括号初始化器列表初始化对象

目录

[编辑] 语法

[编辑] 直接列表初始化

T object { arg1, arg2, ... }; (1)
T { arg1, arg2, ... }; (2)
new T { arg1, arg2, ... } (3)
Class { T member { arg1, arg2, ... }; }; (4)
Class::Class() : member{arg1, arg2, ...} {... (5)

[编辑] 复制列表初始化

T object = {arg1, arg2, ...}; (6)
function( { arg1, arg2, ... } ) ; (7)
return { arg1, arg2, ... } ; (8)
object[ { arg1, arg2, ... } ] ; (9)
object = { arg1, arg2, ... } ; (10)
U( { arg1, arg2, ... } ) (11)
Class { T member = { arg1, arg2, ... }; }; (12)

列表初始化在下列性情形进行:

  • 直接列表初始化(考虑 explicit 和非 explicit 构造函数)
1)花括号初始化器列表(即可以为空的表达式或花括号初始化器列表的花括号环绕列表)初始化具名变量
2)花括号初始化器列表初始化无名临时量
3)new 表达式初始化拥有动态存储期的对象,其中初始化器是花括号初始化器列表
4) 在不使用等号的非静态数据成员初始化器
5) 在构造函数的成员初始化列表中,若使用花括号初始化器列表
  • 复制初始化(考虑 explicit 和非 explicit 构造函数,但只调用非 explicit 构造函数)
6) 以等号后的花括号初始化器列表初始化具名变量
7) 函数调用表达式中,以花括号初始化器列表为实参,以列表初始化初始化函数形参
8)return 语句中以花括号初始化器列表为返回表达式,以列表初始化初始化返回的对象
9)下标表达式中使用用户定义的 operator[] ,其中列表初始化初始化重载运算符的参数
10)赋值表达式中,其中列表初始化初始化重载的 operator= 的参数
11) 函数型转型表达式或其他构造函数调用,其中花括号初始化器列表用于构造函数参数的位置。复制初始化初始化构造函数的形参(注意:此例中的类型 U 不是被列表初始化的类型;而 U 的构造函数的参数是)
12) 在使用等号的非静态数据成员初始化器

[编辑] 解释

T 类型对象的列表初始化效果是:

  • T 是聚合类型且初始化器列表拥有相同或导出类型(可以为 cv 限定)的单个元素,则从该元素初始化对象(对于复制列表初始化为以复制初始化,对于直接列表初始化为以直接初始化)。
  • 否则,若 T 是字符数组且初始化器列表拥有单个元素,元素是类型适当的字符串字面量,则照常从字符串字面量初始化数组。
(C++14 起)
  • 若花括号初始化器列表为空,且 T 是拥有默认构造函数的类类型,则进行值初始化
(C++14 前)
  • 否则,若花括号初始化器列表为空,且 T 是拥有默认构造函数的类类型,则进行值初始化
(C++14 起)
  • 否则,若 Tstd::initializer_list 的特化,则从花括号初始化器列表所初始化的同类型纯右值 (C++17 前),依赖语境直接初始化或复制初始化 T
  • 否则,考虑 T 的构造函数,有二阶段:
  • 所有接收 std::initializer_list 为唯一参数,或若剩余参数拥有默认值情况的首参数的函数得到检验,并为针对拥有单个 std::initializer_list 类型参数的重载决议所匹配
  • 若前一阶段不产生匹配,则 T 的所有构造函数参与针对由花括号初始化器列表的元素所组成的实参集的重载决议,有只允许非窄化转换的限制。若此阶段产生 explicit 构造函数为复制列表初始化的最佳匹配,则编译失败(注意,在简单复制初始化中,完全不考虑 explicit 构造函数)。
  • 否则,若 T 是拥有固定底层类型的有作用域或无作用域枚举类型,且若花括号初始化器列表仅拥有一个初始化器,且若从该初始化器到底层类型的转换非窄化,且若初始化是直接列表初始化,则以转换初始化器到其底层类型的结果初始化该枚举。
(C++17 起)
  • 否则(若 T 不是类类型),若花括号初始化器列表仅拥有一个元素,且 T 要么不是引用类型,要么是与该元素类型兼容的引用类型,则直接初始化(于直接列表初始化)或复制初始化(于复制列表初始化) T ,除了不允许窄化转换。
  • 否则,若 T 是不与该类型元素兼容的引用类型,则列表初始化被引用类型的临时量,并绑定引用到该临时量 (C++17 前)则从列表初始化其结果对象的被引用类型的纯右值表达式直接初始化该引用 (C++17 起)。(若引用是非 const 左值引用则失败)
  • 否则,若花括号初始化器列表无元素,则 T值初始化

[编辑] 窄化转换

列表初始化通过禁止下列者,限制隐式转换

  • 从浮点类型到整数类型
  • long doubledoublefloat 的转换及从 doublefloat 的转换,除非源是常量表达式且不发生溢出
  • 从整数类型到浮点类型,除非源是值能准确存储于目标类型的常量表达式
  • 从整数或无作用域枚举类型到不能表示原类型所有值的整数类型,除非源是值能准确存储于目标类型的常量表达式

[编辑] 注意

每个初始化器子句先序于花括号初始化器列表中后随它的任何初始化器子句。这与函数调用表达式相反,它是无顺序的

花括号初始化器列表不是表达式从而无类型,例如 decltype({1,2}) 为病态。无类型隐含着模板类型推导不能推导出匹配花括号初始化器列表的类型,故给定声明 template<class T> void f(T); 则表达式 f({1,2,3}) 是病态的。然而,可从另外情况推导模板形参,如 std::vector<int> v(std::istream_iterator<int>(std::cin), {}) 的情况,其中迭代器类型从首个参数推导,但亦用于第二形参位置。对于使用关键词 auto 的类型推导有一个例外,它推导任何花括号初始化器列表为 std::initializer_list

亦因为花括号初始化器列表无类型,故在将它用作重载函数调用参数时应用重载决议的特殊规则

聚合体直接从同类型的单元素花括号初始化器列表复制/移动,但非聚合体首先考虑 initializer_list 构造函数:

struct X {
    X() = default;
    X(const X&) = default;
};
 
struct Q {
    Q() = default;
    Q(Q const&) = default;
    Q(std::initializer_list<Q>) {}
};
 
int main() {
  X x;
  X x2 = X { x }; // 复制构造函数(非聚合初始化)
  Q q;
  Q q2 = Q { q }; // initializer_list 构造函数(非复制构造函数)
}
(C++14 起)

[编辑] 示例

#include <iostream>
#include <vector>
#include <map>
#include <string>
 
struct Foo {
    std::vector<int> mem = {1,2,3}; // 非静态成员的列表初始化
    std::vector<int> mem2;
    Foo() : mem2{-1, -2, -3} {} // 构造函数中的成员列表初始化
};
 
std::pair<std::string, std::string> f(std::pair<std::string, std::string> p)
{
    return {p.second, p.first}; // return 语句中的列表初始化
}
 
int main()
{
    int n0{};     // 值初始化(为零)
    int n1{1};    // 直接列表初始化
    std::string s1{'a', 'b', 'c', 'd'}; // initializer_list 构造函数调用
    std::string s2{s1, 2, 2};           // 常规构造函数调用
    std::string s3{0x61, 'a'}; // initializer_list 构造函数偏好 (int, char)
 
    int n2 = {1}; // 复制列表初始化
    double d = double{1.2}; // 临时量的列表初始化,然后复制初始化
 
    std::map<int, std::string> m = { // 嵌套列表初始化
           {1, "a"},
           {2, {'a', 'b', 'c'} },
           {3, s1}
    };
 
    std::cout << f({"hello", "world"}).first // 函数调用中的列表初始化
              << '\n';
 
    const int (&ar)[2] = {1,2}; // 绑定左值引用到临时数组
    int&& r1 = {1}; // 绑定右值引用到临时 int
//  int& r2 = {2}; // 错误:不能绑定右值到非 const 左值引用
 
//  int bad{1.0}; // 错误:窄化转换
    unsigned char uc1{10}; // 可以
//  unsigned char uc2{-1}; // 错误:窄化转换
 
    Foo f;
 
    std::cout << n0 << ' ' << n1 << ' ' << n2 << '\n'
              << s1 << ' ' << s2 << ' ' << s3 << '\n';
    for(auto p: m)
        std::cout << p.first << ' ' << p.second << '\n';
    for(auto n: f.mem)
        std::cout << n << ' ';
    for(auto n: f.mem2)
        std::cout << n << ' ';
}

输出:

world
0 1 1
abcd cd aa
1 a
2 abc
3 abcd
1 2 3 -1 -2 -3

[编辑] 缺陷报告

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

DR 应用于 出版时的行为 正确行为
CWG 1467 C++14 禁止同类型的聚合体和 char 数组初始化 允许同类型初始化
CWG 1467 C++14 单元素列表的 std::initializer_list 构造函数优先级高于复制构造函数 单元素列表直接初始化

[编辑] 参阅