C++之列表初始化详解

1、列表初始化的规则

在C++11中可以直接在变量名后面加上初始化列表来进行对象的初始化。

struct A {
public:
    A(int) {}
};
int main() {
    A a(123);
    A c = { 123 };
    A d{123}; // c++11

    int e = {123};
    int f{123}; // c++11
    return 0;
}

聚合类型可以进行直接列表初始化，那么什么是聚合类呢？

（1）类型是一个普通数组，如int[5]，char[]，double[]等

（2）类型是一个类，且满足以下条件：

• 没有用户声明的构造函数
• 没有用户提供的构造函数(允许显示预置或弃置的构造函数)
• 没有私有或保护的非静态数据成员
• 没有基类
• 没有虚函数
• 没有{}和=直接初始化的非静态数据成员
• 没有默认成员初始化器

文字难以琢磨可以看下面例子帮助理解：

// 有自定义的构造函数，不能列表初始化
class A {
public:
    A(int, int){}
    
    int a;
    int b;
    int c;
};

// 含有虚函数，不是聚合类
class B {
public:
    virtual void func() {} 
    
    int a;
    int b;
};

// 有基类，不是聚合类
class Base {};
class C : public Base { 
public:
    int a;
    int b;
};

// 有等号初始化，不是聚合类
class D {
public:    
    int a;
    int b = 10; 
};

// 含有私有的非静态数据成员，不是聚合类
class E {
public:
    int a;
    int b;
private:
    int c; 
};

// 含有默认成员初始化器，不是聚合类
class F {
public:
    F() : a(0), b(0) {} 
    
    int a;
    int b;
};

2、列表初始化的优点

（1）高效，减少调用构造函数的次数

#include
using namespace std;

class Data
{
public:
    // 无参构造函数
	Data() {cout<<"This is Data constructor1"<<endl;}
	// 拷贝构造函数
	Data(const Data&) {cout<<"This is Data constructor2"<<endl;}
	// 拷贝赋值构造函数
	Data& operator=(const Data&) {cout<<"This is Data constructor3"<<endl;}
};

// 低效写法
class Test1
{
public:
	Test1(Data data) {m_data = data;}
private:
	Data m_data;
};

// 高效写法
class Test2
{
public:
	Test2(Data data) : m_data(data){}
private:
	Data m_data;
};

// 更高效的写法
class Test3
{
public:
	Test3(Data& data) : m_data(data){}
private:
	Data m_data;
};

int main()
{	
    Data a;
    cout<<"---------------THIS IS TEST1---------------"<<endl;
    Test1 t1(a);
    
    cout<<"---------------THIS IS TEST2---------------"<<endl;
    Test2 t2(a);
    
    cout<<"---------------THIS IS TEST3---------------"<<endl;
    Test3 t3(a);
    
    return 0;
}

/*
	输出结果：
	This is Data constructor1
	---------------THIS IS TEST1---------------
	This is Data constructor2
	This is Data constructor1
	This is Data constructor3
	---------------THIS IS TEST2---------------
	This is Data constructor2
	This is Data constructor2
	---------------THIS IS TEST3---------------
	This is Data constructor2
	
	（1）对于TEST1，没有使用列表初始化，所以其私有变量m_data是通过调用Data()定义的，所以会出现“This 	is Data constructor1”，而“This is Data constructor2”是在发生在参数传递调用的拷贝构造，最		后“m_data = data”会发生拷贝赋值，从而调用“This is Data constructor3”
	（2）对于TEST2，“This is Data constructor2”也是在发生在参数传递调用的拷贝构造，而另外一次调用是	发生在列表初始化“Test2(Data data) : m_data(data){}”
	（3）对于TEST3，则是TEST3的构造函数中参数使用了引用，就避免了参数传递而调用的拷贝构造，所以只有一次		调用拷贝构造是发生在列表初始化的时候
*/

（2） 防止类型窄化，避免精度丢失的隐式类型转化

C++11可使用 explicit 关键字对单参数的构造函数进行声明，让编译器无法进行隐式类型转换，但仅限于单参数或者其他参数有默认值的情况下使用。而列表初始化是禁止避免精度丢失的隐式类型转化，不像 explicit 禁止所有的隐式类型转换

int main() {
    // 浮点型到整型的转换
    int a = 1.2; // ok
    int b = {1.2}; // error
	
    // 整型到浮点型的转换
    float c = 1e70; // ok
    float d = {1e70}; // error
	
	// char的枚举类型
    const int i = 1000;
    const int j = 65;
    char k = i; // ok
    char l = {i}; // error

    char m = j; // ok，m为'A'
    char m = {j}; // ok，因为是const类型，这里如果去掉const属性，也会报错
}

（3）可以使用初始化列表接受任意长度的参数

std::initializer_list，它可以接收任意长度的初始化列表，但是里面必须是相同类型T，或者都可以转换为T

class Test {
public:    
    Test(std::initializer_list<int> list) {
        for (auto iter = list.begin(); iter != list.end(); ++iter) {
            vec.push_back(*iter);
        }
    }
private: 
    std::vector<int> vec;
};