C11简洁之道：初始化改进

1、  C++98/03初始化

　　我们先来总结一下C++98/03的各种不同的初始化情况：

//普通数组
int i_arr[3] = {1, 2, 3};

//POD(plain old data)
struct A
{
    int x;

    struct B
    {
        int i;
        int j;
    }b;
}a = {1, {2, 3}};

//拷贝初始化
int i = 0;

class Foo
{
public:
    Foo(int){};
}Foo = 123;

//直接初始化
int j(0);

　　这些不同的初始化方法都有各自的适用范围和方法，但是种类繁多的方法却没有一种可以通用的。所以C++11提出了初始化列表的方法来解决通用问题。

2、  统一初始化方法

　　其实C++98/03中已经存在初始化列表的方法，只是范围比较窄，只适用于常规POD类型。

int i_arr[3] = {1, 2, 3};
int i_arr2[] = {1, 2, 3, 4};

struct B
{
     int i;
     int j;
}b = {1, 2};

　　而C++11将这种初始化方法适用于所有类型的初始化。我们先来看一组例子：

class Foo
{
public:
    Foo(int){};
private:
    Foo(const Foo &){};
};
 
void testFunc(void)
{
    Foo val1(123);
    //Foo val2 = 123; // error:Foo::Foo(const Foo &) is private.
    Foo val3 = {123};
    Foo val4{123};
    int a5 = {2};
    int a6{3};
}

　　val3、val4使用了初始化列表来初始化对象，a3虽然使用等号，但是并不影响到私有拷贝，仍然是初始化列表的方式，等统一val1的直接初始化，而val2则调用私有拷贝函数会报错。a5、a6则是一般类型的初始化，val4和a6都是C++11特有的，而C++98/03并不支持。

　　新的初始化方法是变量名后面加{}来进行初始化，{}内则是初始化的内容，等号是否存在并不影响。

type val {};

　　C++11的新方式同样支持new操作符：

int *a = new int{5};
double b = double {12.34};
int *arr = new int[3]{1,2,3};

　　a指向了new操作符分配的一块内存，通过初始化列表将内存的初始值指定为了5；

　　b是对匿名对象进行初始化之后然后进行拷贝初始化；

　　arr则是通过new动态申请一个数组，并通过初始化列表进行初始化。

　　初始化列表还有一个特殊的地方，就是作为函数的返回值。

struct Foo
{
    Foo(int, double){};
};

Foo testFunc(void)
{
    return {12,  12.3};
}

　　在C++11中，初始化列表是非常方便的，不仅统一了对象的初始化方式，还使代码更加简洁清晰。

3、  使用细节

3.1 自定义类型初始化

　　当我们在C++11中使用初始化列表时，可能有以下情况：

struct A
{
    int x;
    int y;
}a = {123,123};   //a.x = 123, a.y = 123

struct B
{
    int x;
    int y;
    B(int, int) : x(0), y(0) {};
}b = {123,123};   //b.x = 0, b.y = 0

　　这个例子说明什么问题呢，a是以C++98/03的聚合类型来初始化的，用拷贝的方式初始化a中的成员，而b呢，由于自定义了构造函数，所以初始化是以构造函数来初始化的。所以有以下结论：

　　当使用初始化列表时，如果是聚合类型，则以拷贝的方式来初始化成员，如果是非聚合类型，则是以构造函数来初始化成员。

3.2 聚合类型

　　提了这么多的聚合类型，那么到底什么是聚合类型呢？我们来看聚合类型的定义：

　　1)  类型是普通数组（int[10],char[],long[2][3]等）。

　　2)  类型是一个类，且：

• 无用户自定义构造函数；
• 无私有或者保护的非静态成员；
• 无基类；
• 无虚函数；
• 无{}和=直接初始化的非静态数据成员。

3.2.1 数组

　　对于数组而言，就很简单了，只要该类型是一个普通的数组，如果数组的元素并不是聚合类型，那么这个数组也是一个聚合类型：

int [] = {1,2,3};
std::string s_arr[3] = {“hello”,  “C++”,  “11”};

3.2.2 存在自定义构造函数

struct A
{
    int x;
    int y;
    int z;
    A(int, int){};
}; 

A a = {123, 123, 12};

　　当一个自定义类拥有自己的构造函数使，无法将该类看作一个聚合类型，必须通过自定义的构造函数才能构造对象。

3.2.3 存在私有或者非静态成员

struct A
{
    int x;
    int y;
protected:
    int z;
}; 

A a = {123, 123, 12}; //error

struct B
{
    int x;
    int y;
protected:
    static int z;
}; 

B b = {123, 123}; //ok

　　例子中，A的实例化是失败的，因为z是一个受保护的非静态成员。而b是成功的，因为z是一个受保护的静态数据成员，所以，类成员里面的静态数据成员是不能通过初始化列表来初始化的，静态数据成员的初始化遵循静态成员的初始化方式。

3.2.4 有基类或者虚函数

　　有基类或者虚函数同样不适用于使用初始化列表。

struct A
{
    int x;
    int y;
    virtual void fun(){};
}; 

A a = {123, 123}; //error

class B {};

struct C : public B
{
    int x;
    int y;
}; 

B b = {123, 123}; //error

3.2.5 {}和=初始化的非静态数据成员

struct A
{
    int x;
    int y = 2;
}; 

A a = {123, 123}; //error

　　在类型A中，y在声明时即被=初始化为2，所以A不再是一个聚合类型。

　　这个例子中需要注意的是，C++11中放宽了类型申明的初始化操作，即在非静态数据成员的声明时调用{}或者=来对成员进行初始化，但是造成的影响是该类型不再是聚合类型，所以不能直接使用初始化列表。所以，如果要使用初始化列表就必须自己定义一个构造函数。

3.2.6 聚合类型并非递归

struct A
{
    int x;
    int y;
private:
    int z;
}; 

A a{1, 2, 3}; // error

A a1{}; //ok

struct B
{
    A a;
    int x;
    double y;
};

B b{{}, 1, 2.5};

　　A有一个私有化的非静态成员，所以使用A a{1, 2, 3}是错误的，但是可以调用他的无参构造函数，所以在B中，即使成员a是一个非聚合类型，但是B仍然是一个聚合类型，可以直接使用初始化列表。

3.2.6 小结

　　根据这么多例子，我们得到以下结论：

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

4、  初始化列表

4.1 任意长度的初始化列表

　　在c++中，对于stl容器和未显示数组长度的数组可以进行任意长度的初始化，在初始化的时候可以书写任意长度的内容。

int i_arr[] = {1,2,3,4};

std::vector<int> veci_t = {1,2,3,4};

std::map<std::string, int> mapsi_t = {{"1", 1}, {"2", 2}, {"3", 3}};

　　但是对于自定义类型不具备这种能力，但是C++11解决了这个问题，C++11中可以通过轻量级模板std::initalizer_list来解决这个问题。我们只需要添加一个std::initializer_list的构造函数，这个自定义类型即可拥有这种任意长度初始化列表来初始化的能力。

class Foo
{
public:
    Foo( std::initializer_list<int> list ) {};
};

Foo foo = {1,2,3,4,5};

　　std::initializer_list负责接收初始化列表，可以通过for循环来读取其中的元素，并将元素做操作。不仅可以作为类型的初始化，同样的，可以作为函数参数传递同类型的数据集合。在任何需要的时候，都可以使用std::initializer_list来一次性传递多个参数。

// code1
class FooVector
{
public:
    FooVector(std::initializer_list<int> list)
    {
        for(auto it = list.begin(); it != list.end(); ++it)
        {
            mveci_content.push_back(*it);
        }
    }
private:
    std::vector<int> mveci_content;
};

FooVector foo1 = {1,2,3,4,5};

//code2
using pair_t = std::map<int, int>::value_type;
class FooMap
{
public:
    FooMap(std::initializer_list<pair_t> list)
    {
        for(auto it = list.begin(); it != list.end(); ++it)
        {
            mmapii_content.insert(*it);
        }
    }
private:
    std::map<int, int> mmapii_content;
};

FooMap foo2 = {{1,2}, {3,4}, {5,6}};
 
//code3
void vFunc(std::initializer_list<int> list)
{
    for(auto it = list.begin(); it != list.end(); ++it)
    {
        std::cout << *it << std::endl;
    }
}

void vCallFunc(void)
{
    vFunc({});
    vFunc({1,2,3,4});
}

4.2 std::initializer_list使用细节

　　std::initializer_list的特点如下：

• 它是一个轻量级的容器类型，内部定义了iterator等容器等必须的概念；
• 可以接收任意长度的初始化列表，但是要求元素必须都是同种类型；
• 有三个成员接口，size(),begin(),end()；
• 只能被整体初始化或者赋值。

　　//获取长度

std::initializer_list<int> list = {1,2,3};  //初始化
size_t len = list.size();       //len = 3

　　std::initializer_list的访问只能通过begin()和end()来进行循环遍历，遍历取得的迭代器是只读的，所以无法修改其中元素的值，但是可以整体赋值来修改其中的元素。

std::initializer_list<int> list;
size_t len = list.size();  //len = 0
list = {1,2,3,4,5};
len = list.size();   //len = 5
list = {1,2};
len = list.size();    //len = 2

　　在研究了std::initializer_list的用法之后，我们来看std::initializer_list的效率。很多时候，如果容器内部是自定义类型或者数量较大，那么是不是就像vector之类的容器一样，把每个元素都赋值一遍呢？答案是不是！std::initializer_list是非常高效的，它的内部并不保存初始化列表元素中的拷贝，仅仅保存初始化列表中的引用。

　　如果我们按照下面的代码来使用std::initializer_list是错误的，虽然可以正常通过编译，但是可能无法得到我们希望的结果，因为a，b在函数结束时生存周期也结束了，返回的是不确定的内容。

std::initializer_list<int> func1(void)
{
    int a = 1, b = 2;
    return {a, b};  //a,b在返回时并没有拷贝
}

　　正确的用法应该是这样，通过真正的容器或者具有转移拷贝语意的物件来替代std::initializer_list返回的结果。

std::vector<int> func2(void)
{
    int a = 1, b = 2;

    return {a, b};  //ok
}

　　我们应该将std::initializer_list看作保存对象的引用来使用，在它持有的对象的生命周期结束之前来完成传递。

5、  防止类型收窄

5.1 类型收窄的情况

　　我们先来看一段代码：

struct Foo
{
    Foo(int i) { std::cout << i << std::endl;}
};

Foo foo(1.2);

　　这个例子就是类型收窄的情况，虽然说能够正常通过编译，但是在传递i之后不能完整的保存浮点数的数据。

　　我们来看C++中有哪些情况会有类型收窄的情况：

• 从一个浮点数隐式转换为一个整数，如int I = 2.2;
• 从高精度浮点数隐式转换为低精度浮点数，如long doule隐式转换为double或者float；
• 从一个整数隐式转换为一个浮点数，并且超出了浮点数的范围，如float f = (unsigned long long ) – 1;
• 从一个整型隐式转换为一个长度较短的整型数，并且超出了长度较短的整型数范围，如char x = 65536;

　　这些类型收窄的情况，在编译器并不会报错，但是可能存在潜在的错误。

5.2 C++11的改善

　　C++11中可以通过初始化列表来检查，防止类型的收窄。我们来看一组例子：

int a = 1.1;            //ok
int b = {1.1};          //error

float fa = 1e40;          //ok
float fb = {1e40};        //error

float fc = (unsigned long long) -1;         //ok
float fd = { (unsigned long long) -1 };     //error
 
float fe = (unsigned long long)1;           //ok
float ff = {(unsigned long long)1};         //ok

const int x = 1024, y = 1;
char c = x;                       //ok
char d = {x};                     //error
char e = y;                       //ok
char f = {y};                     //ok

　　在C++11中，遇到各种类型收窄的情况，初始化列表是不允许这种转换的，上述例子中，如果x，y去掉const限定符，最后的f也会因为类型收窄而报错。