c++11——列表初始化

1. 使用列表初始化

    在c++98/03中，对象的初始化方法有很多种，例如

int ar[3] = {1,2,3};
int arr[] = {1,2,3};    //普通数组
struct A{
    int x;
    struct B{
       int y;
       int z;
    } b;
}a = {1, {3,4}};        //POD类型，可以直接使用memcpy复制的对象

int i = 0;
Foo foo = f;//拷贝初始化

int i(0);
Foo f(123); //直接初始化

    在c++98/03中，普通数组合POD类型，可以通过初始化列表来进行初始化。c++11中，可以对任意类型对象使用初始化列表进行初始化。 
    列表初始化就是在一个变量后给出一个={},或者直接一个{}，括号中含有需要的数据。

class Foo{
public:
    Foo(int){};
private:
    Foo(const Foo&);
};
int main(){
    Foo a1(123);
    Foo a2 = 123;   //先隐式转换将123转化成一个Foo对象，然后调用operator=进行拷贝构造。
    //错误，不能使用拷贝构造函数
    
    Foo a3 = {123}; //列表初始化,虽然使用了=，但仍然是列表初始化，私有的拷贝构造无效
    Foo a4{123};    //列表初始化
    int a5 = {1};   
    int a6{2};
    
    //new 操作符等可以使用圆括号进行初始化的地方，也可以使用列表初始化
    int* a = new int{1, 2, 3};
    double b = double{12.00};
    int* arr = new int[3]{2,4,5};
    
    //列表初始化还可以直接使用在函数的返回值上
    struct Foo{
        Foo(int, double){};
    };
    Foo func(void){
        return {123, 12.00}; //返回构造的Foo对象，使用列表初始化
    }
    return 0;
}

2. 列表初始化的使用细节

    c++11在进行列表初始化的时候，需要进行初始化的对象为聚合体。

c++聚合体

    聚合类型的定义： 
（1）类型是一个普通数组 
（2）类型是一个类，而且： 
    （a）无用户自定义的构造函数 
    （b）无私有或保护的非静态数据成员 
    （c）无基类 
    （d）无虚函数 
    （e）不能有{}和=直接初始化的非静态数据成员

对于情形(e)，举个例子
struct ST{
    int x;
    double y = 0.0;
};
ST s{1, 2.3};   //错误，不能有{}或=直接初始化的非静态数据成员

在c++98/03中，y这种非静态数据成员，本身就不能在声明时进行这种初始化工作，但是在c++11中，非静态数据成员也可以在声明的同时进行初始化工作（即使用{}或=初始化）。

struct ST{
    int x;
    int y;
    ST(int a, int b):x(0), y(0){};
};
ST st{1, 2}; //这里进行初始时，不会进行列表初始化，而是调用的构造函数。因此，st.x = 0, st.y = 0.

    聚合类型的定义并不是递归的，即当一个类的非静态成员是非聚合类型时，这个类也可能是聚合类型。

struct ST{
    int x;
    double y;
private:
    int z;
};
ST s{1, 2.4, 1};//错误，不是聚合类型，无法使用列表初始化
struct Foo{
    ST st;
    int x;
    double y;
};
Foo foo{{}, 1, 2.3};//虽然ST并不是一个聚合类型，但是Foo为一个聚合类型。对于非聚合类型成员st初始化时，**使用空的{}，相当于调用无参构造函数**

c++11的初始化列表赋值

对于一个聚合类型，使用初始化列表相当于对其中的每个元素分别赋值；而对于非集合类型，则需要先自定义一个合适的构造函数，此时使用初始化列表将调用它对应的构造函数。

3. 初始化列表

    c++11中的stl容器拥有和未显示指定长度的数组一样的初始化能力，代码如下：

int arr[]{1,2,3};
std::map<std::string,int>mm={
{"123", 1}, {"hello", 2}, {"fuck", 3}
};
std::set<int> = {1,2,3};

stl中的容器是通过使用std::initializer_list 这个轻量级的模板来实现上述功能。 
std::initializer_list 
（1）它是一个轻量级的容器类型，内部定义了iterator等容器必须的概念 
（2）对于std::initializer_list< T>而言，它可以接受任意长度的初始化列表，但要求元素必须为类型T 
（3）它有三个成员接口: size(), begin(), end() 
（4）它只能被整体初始化或赋值，不能单独修改其中的某个元素（因为由上一条，知道它不提供接口） 
（5）它内部存放的是元素的引用，因此不会进行拷贝操作，所以需要注意在使用的时候保证内部存放的元素有效期

    std::initializer_list<int> list = {1,2,3,4};
    size_t n = list.size(); // 4
    list = {4, 5, 6}; //整体赋值

4. 防止类型收窄

    类型收窄指的是导致数据内容发生变化或者精度丢失的隐式类型转换。类型收窄包含如下几种情况： 
（1）从一个浮点数隐式转换到一个整型数 
（2）从高精度浮点数转换为低精度浮点数 
（3）从一个整型数隐式转换为一个浮点数，并且超出了浮点数的表示范围，如 float x= (unsigned long long )-1; 
（4）从一个整型数转换为一个长度较短的整型数，并且超出了长度较短的整型数的表示范围。如char x = 3333; 
    在c++98/03中，出现上面的类型收窄的情况，编译器不会报错。在c++11中，可以通过列表初始化来检查以及防止类型收窄。

    int a = 1.1; //可以
    int a = {1.1}; //出错