list Initialization各版本异同
本节内容
学习列表初始化在各个版本更新中的异同
学前知识了解
以下是窄化转换的几种情形：
- 浮点型转整数
- 低精度浮点数转高精度浮点数（double转float）
- 整数转浮点数
- 整数转更小整数( char c { 256 }) ，溢出
- 指针转bool，允许 bool b (pX != nullptr )
列表初始化：使用花括号初始值设定项列表初始化对象
直接列表初始化
- 花括号初始化设定项列表初始化变量
- 花括号初始值设定项列表无名临时对象
- 用new动态开辟内存的对象
- 非静态数据成员初始化设定项
- 构造函数成员初始化项
复制列表初始化
- 在等号后花括号初始值设定项列表初始化变量
- 在函数调用中，参数使用花括号初始值设定项列表
- 在return中，列表初始化返回对象
- 在使用operator[]访问对象时，使用列表初始化重载运算符参数
- 赋值表达式中，列表初始化代替构造函数按顺序赋值
- 在使用等号的非静态数据成员初始值设定项
列表初始化规则如下：
1、如果花括号里是指定初始化器{ .成员名= 值 } ，且为聚合类型（无自定义构造函数、无基类、无虚函数类型），则满足
- 指定初始化器的成员名，必须是该类的直接非静态数据成员
- 指定成员顺序执行聚合初始化（无需匹配类成员声明顺序）
struct Point { int x; int y ;};
Point p {.y = 2 , .x = 10 ; }; //C++20
2、如果该类是聚合类型，且花括号里是普通初始化列表（无指定成员）
- 对聚合列表初始化，直接安装列表顺序初始化成员
- 对复制列表初始化，列表只能有一个元素，且类型与该类相同/是其基类
Point p1{ 1 , 2 }; // x = 1 ,y = 2;
Point p2 = { 1 }; // x = 1,y 默认初始化
3、字符数组的字符串字面量初始化
如果该类是字符数组，且花括号里是一个字符串字面量，数组按字符串字面量初始化（自动补/0）
char str[5] = { "hello" } ; //编译警告但会允许通过，不会填充/0，但是在使用strlen和memcpy时候会崩溃
char str1[6] = "hello"; //末位补0
4、非聚合类的聚合初始化，执行聚合初始化（按成员顺序匹配列表），传统写法
5、空列表+默认构造函数的初始化
如果花括号是空的，且该类有默认构造函数，执行值初始化（调用默认构造函数，内置类型初始化为0）
int a = {}; // a= 0
std::string s{}; //std::string()
6、std:initalizer_list构造函数匹配，如果该类定义了std::initializer_list作为参数构造函数：
- 优先匹配以std::initializer_list作为唯一参数或第一个参数的构造函数
- 如果匹配失败，在匹配普通构造函数
- 如果同时匹配，优先选std::initializer_list版本
class Test
{
public:
Test(std::initializer_list<int>) { cout << " init list " << endl; }
Test(int,int) { cout << " normal constructor " << endl; }
}
Test t1 { 1, 2 }; //优先匹配std::initializer_list
Test t2 (1,2) ; //匹配普通构造
7、枚举类型的列表初始化
如果该类是枚举类型，且花括号里只有一个值v，同时满足
- v是标量类型
- v可隐式转换为枚举底层类型
- 转换时非窄化的（int 转 enum { Red = 1 }合法，double转enum不合法），则枚举被直接列表初始化
enum Color { Red = 1 , Green = 2 , Blue = 3 };
Color c {1}; // C++17合法
8、非引用类型的直接/复制列表初始化，如果该类不是引用类型，且花括号里只有一个值，
- 指向直接初始化列表 （等价于 T obj(v) ）;
- 复制列表初始化（等价于T obj = v ）;
- 不允许窄化转换（int 转 char需要显式转换 ）
9、引用类型列表初始化（C++17）,如果该类是一个引用类型，花括号里是一个值v :
- 生成一个临时对象，通过复制列表初始化该临时对象
- 引用绑定到这个临时对象
- 若引用是非const左值引用，则失败（左值引用不能绑定临时对象）
const int & ref { 10 } // //临时对象int(10) 被绑定到ref里面
int & ref1 { 20 } ; // error， 非const左值引用不能绑定临时对象
10、空列表零初始化，如果花括号里没有任何值，且该类没有默认构造函数，执行零初始化（内置类型为0）
列表初始化std::initializer_list
std::initializer_list<int> lists = { 1, 2, 3, 4 };
void f ( std::initializer_list<int> lists );
f ({ 1,2,3,4 });
- 当初始化一个对象之后，编译器会在后台建立一个 const int { 1, 2, 3, 4 }的临时数组，称为后备数组。
- 由于后备数组中的各个元素都是从原语句拷贝过来的，所以每个元素的拷贝/移动函数必须是可访问的
- std::initializer_list对象本身不存储数据，只是指向了后备数组的指针和长度
- 不允许发生窄化转换（double转int， 发生溢出或截断等）
- f ({ 1,2,3,4 })在f 返回之后，立即销毁，跟普通对象行为一致
- 当对象被绑定到后备数组之后，生命周期会被延长 ，例子中lists已经绑定了后备数组，并非引用写法
bool fun(std::initializer_list<int> il1, std::initializer_list<int> il2)
{
return il2.begin() == il1.begin() + 1;
}
bool overlapping = fun({1, 2, 3}, {2, 3, 4}); // the result is unspecified: the back arrays can share storage within {1, 2, 3, 4}
解释：结果是unspecified（未指定的），在不同编译器返回结果可能是不同，原因如下：
当运行到fun ( { 1, 2, 3 } , { 2, 3 ,4 })时，生成两个后备数字 const int {1 ,2 ,3 } ,const int { 2 ,3, 4 }，因为两者都是const 数据时不会产生修改且含有大量重叠数字，所以编译器会优化空间为 const int { 1 ,2, 3, 4}，此时判断结果是true
初始化列表小知识点
1、初始化列表中的元素或者函数调用，严格从左到右
int func ( int i ) { cout << " i <<endl; }
int arr[] = { func{1} , func{2} , func{3}};
2、花括号列表本身并没有类型，所以使用decltype( {1,2} )是非法的，但是支持auto推导出std::initializer_list
3、当花括号作为参数时，优先匹配std::initializer_list重载，除非使用括号直接调用
class Test
{
public:
Test(std::initializer_list<int>){}
Test(int a,int b){}
}
Test{1,2}; //优先调用初始化列表
Test(1,2); //调用二元参数
4、当其他可推导参数作为首参时，后续花括号类型默认使用首参类型
std::vector v(std::istream_iterator(std::cin), {}); //正确， {}默认为int
std::vector v({} , std::istream_iterator(std::cin)); //错误，首参不可推导
直接列表初始化
//通过成员名指定初始化，无需在意顺序
struct Person
{
string name;
int age;
int classId;
}
Person b { .age = 12 , .name = "Alia" , classId = 0}; //使用指定初始化器，可打乱顺序
Person b1{} = { .name = "Bob" , . classId = 3 , .age = 15};
std::vector<Person> vec;
vec.push_back( { "Elice",15,3 };
vec.emplace_back( { .classId = 5 , .name = "Bob" , .age = 11 } ) ;
//省略对象名称，用于临时对象
void PrintMessage (const Person & p } { cout << p.name << p.age << p.classId << endl; }
PrintMessage(Person{ .classId = 0 , .name = "Alice" , .age = 15});
PrintMessage( { .classId = 0 , .name = "Alice" , .age = 15} );
//在堆上创建对象，返回指针
Person* p = new Person { .name = "Aliys" , .age = 13 , .classId = 3 };
if(p2) delete p;
Person GetMessage() { return { .name = "Alice" , . classId = 5 , .age = 15 };
//非静态成员在声明时直接初始化
Class Student
{
public:
Person p { "Bob" , 13 , 1};
Person b { .age = 12 , .name = "Alia" , classId = 0};
}
//构造函数中，初始化成员对象（优先级高于类内初始化）
Class Student
{
Person pp;
public:
Student(string n , int a , int c) : pp {.age = a , .name = n , .classId = c }{}
}
struct Base { int a ; int b ; };
struct Derived : Base
{
int c;
Derived() : Base { .b = 20, .a = 13 } ， c {19} {}
}
C++11初次引入
支持花括号列表初始化容器 / 对象
auto可推导为std::initializer_list，模板不支持推导，decltype也不支持
本质为指向一组const数组的指针和长度
std::initializer_list<int> arr = { 1, 2, 3, 4, 5 } ; //复制初始化
auto arr1 = { 2 ,4, 5 } ; //自动推导为initializer_list
template<typename T>
void func( T t ) {}
func({ 1 ,2 ,3 }); //error，无法模板直接推导为int
func( std::initializer_list<int>{ 1, 2, 3, 4}); //ok , 显式指定类型
C++14推导增强
返回类型支持Initializer_list
常量表达式中可调用initializer_list
标准库容器全面支持initializer_list构造
auto getList() { return { 1, 2, 3 }; }; //自动推导为initializer_list
//编译期即可获取
constexpr int getSize()
{
std::initializer_list<int> lists = { 1 ,2 ,3 };
return lists.size();
}
std::map<int,string> maps = { { 1, " abc " } , { 2 , " Hello " } }; //支持初始化列表 初始化
C++17 求值顺序严格化
明确后备数组（临时数组）是编译器实体化的prvalue数组
花括号内求值严格从左到右
聚合类型初始化不再优先匹配std::initializer_list构造函数
class Base { int a ; int b }
class Test
{
public:
Test(std::initializer_list<int>) { cout << " init list " << endl; }
Test(int,int) { cout << " normal constructor " << endl; }
}
Base base { 1, 2 }; //优先匹配到直接初始化 a = 1 , b = 2
Test t1 { 1, 2 }; //优先匹配std::initializer_list
C++20 适配模板/约束/范围库
模块系统隐式支持 initializer_list
结合Concepts约束initializer_list类型
范围库支持initializer_list作为范围
template < class T >
concept IntList = std::same_as<T, std::initializer_list<int>>;
template <IntList T > //特约版本
void PrintList( T t1) { for(const auto& item : t1 ) cout << item << endl; }
auto t1 = { 1, 2 ,3 };
auto even = t1 | std::views::filter([](int n){ return n % 2 == 0; });
for ( const auto& item : even ) cout << item << endl;
PrintList({ "Bob" , " Alice " } ); //error 约束只支持int
PrintList({ 1, 2, 3 }); // ok
C++23 推导优化
构造函数推导智能，减少显式类型指定
明确悬空引用场景，优化错误提示
支持用户定义字面量适配initializer_list
auto badList = [](){ return { 1, 2, 3 } };
//该句结束后 立刻销毁badList, 接下来在使用就会变成悬空引用
template <char... Cs>
constexpr auto operator""_list()
{
return std;:initializer_list<int>( (Cs - '0' )... );
}
auto lists = 123_list;
自定义字面量， operator""_list，123_list相当于带入了 { ‘1’ ,‘2’ , ‘3’ } ，进过Cs - '0’时，转化为 { 1, 2, 3 };
