C++11 新特性之列表初始化

技术专帖

       本文是C++11新特性介绍的第十七部分，涉及到列表初始化相关的新特性。

前言

       在我们实际编程中，我们经常会碰到变量初始化的问题，对于不同的变量初始化的手段多种多样，比如说对于一个数组我们可以使用 int arr[] = {1,2,3}的方式初始化。

统一的初始化方法

       在C++98/03中我们只能对普通数组和POD(plain old data，简单来说就是可以用memcpy复制的对象)类型可以使用列表初始化，如下：
       数组的初始化列表：int arr[3] = {1,2,3}
       POD类型的初始化列表：

1
2
3
4
5
struct A
{
    int x;
    int y;
}a = {1,2};

       在C++11中初始化列表被适用性被放大，可以作用于任何类型对象的初始化。如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Foo
{
public:
    Foo(int) {}
    
private:
    Foo(const Foo &);
};
int main()
{
    Foo a1(123); //调用Foo(int)构造函数初始化
    Foo a2 = 123; //error Foo的拷贝构造函数声明为私有的，该处的初始化方式是隐式调用Foo(int)构造函数生成一个临时的匿名对象，再调用拷贝构造函数完成初始化
    Foo a3 = { 123 }; //列表初始化
    Foo a4 { 123 }; //列表初始化
    int a5 = { 3 };
    int a6 { 3 };
    return 0;
}

       由上面的示例代码可以看出，在C++11中，列表初始化不仅能完成对普通类型的初始化，还能完成对类的列表初始化，需要注意的是a3，a4都是列表初始化，私有的拷贝并不影响它，仅调用类的构造函数而不需要拷贝构造函数，a4，a6的写法是C++98/03所不具备的，是C++11新增的写法。
       同时列表初始化方法也适用于用new操作等圆括号进行初始化的地方，如下：

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

       让人惊奇的是在C++11中可以使用列表初始化方法对堆中分配的内存的数组进行初始化，而在C++98/03中是不能这样做的。

列表初始化的一些使用细节

       虽然列表初始化提供了统一的初始化方法，但是同时也会带来一些使用上的疑惑需要各位苦逼码农需要注意，比如对下面的自定义类型的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
struct A
{
    int x;
    int y;
}a = {123, 321};
//a.x = 123 a.y = 321
struct B
{
    int x;
    int y;
    B(int, int) :x(0), y(0){}
}b = {123,321};
//b.x = 0  b.y = 0

       对于自定义的结构体A来说模式普通的POD类型，使用列表初始化并不会引起问题，x，y都被正确的初始化了，但看下结构体B和结构体A的区别在于结构体B定义了一个构造函数，并使用了成员初始化列表来初始化B的两个变量，，因此列表初始化在这里就不起作用了，b采用的是构造函数的方式来完成变量的初始化工作。
       那么如何区分一个类(class struct union)是否可以使用列表初始化来完成初始化工作呢？关键问题看这个类是否是一个聚合体（aggregate)，首先看下C++中关于类是否是一个聚合体的定义：
       （1）无用户自定义构造函数。
       （2）无私有或者受保护的非静态数据成员
       （3）无基类
       （4）无虚函数
       （5）无{}和=直接初始化的非静态数据成员。下面我们逐个对上述进行分析。
       1、首先存在用户自定义的构造函数的情况，示例如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
struct Foo
{
    int x;
    int y;
    Foo(int, int){ cout << "Foo construction"; }
};
int main()
{
    Foo foo{ 123, 321 };
    cout << foo.x << " " << foo.y;
    return 0;
}

       输出结果为：Foo construction -858993460 -858993460
       可以看出对于有用户自定义构造函数的类使用初始化列表其成员初始化后变量值是一个随机值，因此用户必须以用户自定义构造函数来构造对象。
       2、类包含有私有的或者受保护的非静态数据成员的情况

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
struct Foo
{
    int x;
    int y;
    //Foo(int, int, double){}
protected:
    double z;
};
int main()
{
    Foo foo{ 123,456,789.0 };
    cout << foo.x << " " << foo.y;
    return 0;
}

       实例中z是一个受保护的成员变量，该程序直接在VS2013下编译出错，error C2440: ‘initializing’ : cannot convert from ‘initializer-list’ to ‘Foo’，而如果将z变量声明为static则，可以用列表初始化来，示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
struct Foo
{
    int x;
    int y;
    //Foo(int, int, double){}
protected:
    static double z;
};
int main()
{
    Foo foo{ 123,456};
    cout << foo.x << " " << foo.y;
    return 0;
}

       程序输出：123 456，因此可知静态数据成员的初始化是不能通过初始化列表来完成初始化的，它的初始化还是遵循以往的静态成员的额初始化方式。
       3、类含有基类或者虚函数

1
2
3
4
5
6
7
8
9
10
11
12
13
struct Foo
{
    int x;
    int y;
    virtual void func(){};
};
int main()
{
    Foo foo {123,456};
    cout << foo.x << " " << foo.y;
    return 0;
}

       上例中类Foo中包含了一个虚函数，该程序也是非法的，编译不过的，错误信息和上述一样cannot convert from ‘initializer-list’ to ‘Foo’。

1
2
3
4
5
6
7
8
9
10
11
12
13
struct base{};
struct Foo:base
{
    int x;
    int y;
};
int main()
{
    Foo foo {123,456};
    cout << foo.x << " " << foo.y;
    return 0;
}

       上例中则是有基类的情况，类Foo从base中继承，然后对Foo使用列表初始化，该程序也一样无法通过编译，错误信息仍然为cannot convert from ‘initializer-list’ to ‘Foo’，
       4、类中不能有{}或者=直接初始化的费静态数据成员

1
2
3
4
5
6
7
8
9
10
11
12
struct Foo
{
    int x;
    int y= 5;
};
int main()
{
    Foo foo {123,456};
    cout << foo.x << " " << foo.y;
    return 0;
}

       在结构体Foo中变量y直接用=进行初始化了，因此上述例子也不能使用列表初始化方法，需要注意的是在C++98/03中，类似于变量y这种直接用=进行初始化的方法是不允许的，但是在C++11中放宽了，是可以直接进行初始化的，对于一个类来说如果它的非静态数据成员使用了=或者{}在声明同时进行了初始化，那么它就不再是聚合类型了，不适合使用列表初始化方法了。
       在上述4种不再适合使用列表初始化的例子中，需要注意的是一个类声明了自己的构造函数的情形，在这种情况下使用初始化列表是编译器是不会给你报错的，操作系统会给变量一个随机的值，这种问题在代码出BUG后是很难查找到的，因此这种情况不适合使用列表初始化需要特别注意，而其他不适合使用的情况编译器会直接报错，提醒你这些场景下使用列表初始化时不合法的。
       那么是否有一种方法可以使得在类不是聚合类型的时候可以使用列表初始化方法呢？相信你肯定猜到了，作为一种很强大的语言不应该也不会存在使用上的限制。自定义构造函数+成员初始化列表的方式解决了上述类是非聚合类型使用列表初始化的限制。看下面的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
struct Foo
{
    int x;
    int y= 5;
    virtual void func(){}
    int z;
public:
    Foo(int i, int j, int k) :x(i), y(j), z(k){ cout << z << endl; }
};
int main()
{
    Foo foo {123,456,789};
    cout << foo.x << " " << foo.y;
    return 0;
}

       输出结果为 789 123 456 ，可见，尽管Foo中包含了私有的非静态数据以及虚函数，用户自定义构造函数，并且使用成员列表初始化方法可以使得非聚合类型的类也可以使用列表初始化方法，因此在这里给各位看官提个建议，在对类的数据成员进行初始化的时候尽量在类的构造函数中用成员初始化列表的方式来对数据成员进行初始化，这样可以防止一些意外的错误。

初始化列表

       在上面的使得一个类成为非聚合类的例子2、3、4中，这些非法的用法编译器都报出的错误是cannot convert from ‘initializer-list’ to ‘Foo’，那么这个initializer-list是什么呢？为什么使用列表初始化方法是将initializer-list转换成对应的类类型呢？下面我们就来看看这个神秘的东西

任何长度的初始化列表

       在C++11中，对于任意的STL容易都与和为显示指定长度的数组一样的初始化能力，如：

1
2
3
4
int arr[] = { 1, 2, 3, 4, 5 };
std::map < int, int > map_t { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } };
std::list<std::string> list_str{ "hello", "world", "china" };
std::vector<double> vec_d { 0.0,0.1,0.2,0.3,0.4,0.5};

       STL容易跟数组一样可以填入任何需要的任何长度的同类型的数据，而我们自定义的Foo类型却不具备这种能力，只能按照构造函数的初始化列表顺序进行依次赋值。实际上之所以STL容易拥有这种可以用任意长度的同类型数据进行初始化能力是因为STL中的容器使用了std::initialzer-list这个轻量级的类模板，std::initialzer-list可以接受任意长度的同类型的数据也就是接受可变长参数{…}，那么我们是否可以利用这个来改写我们的Foo类，是的Foo类也具有这种能力呢？看下面例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
struct Foo
{
    int x;
    int y;
    int z;
    
    Foo(std::initializer_list<int> list)
    {
        auto it= list.begin();
        x = *it++;
        y = *it++;
        z = *it++;
    }
};
int main()
{
    Foo foo1 {123,456,789};
    Foo foo2 { 123, 456};
    Foo foo3{ 123};
    Foo foo4{ 123, 456, 789,258 };
    cout << foo1.x << " " << foo1.y << " " << foo1.z<<endl;
    cout << foo2.x << " " << foo2.y << " " << foo2.z << endl;
    cout << foo3.x << " " << foo3.y << " " << foo3.z << endl;
    cout << foo4.x << " " << foo4.y << " " << foo4.z << endl;
    return 0;
}

       程序的输出结果为：

1
2
3
4
123 456 789
123 456 -858993460
123 -858993460 -858993460
123 456 789

       在上面的例子中我们用std::initialzer-list将类改写，是的类Foo也具有了接受可变长参数的能力，在Foo类中定义了三个变量，分别在main函数中使用1个2个3个4个参数的列表初始化方法来初始化foo变量，可见，由程序的输出结果可知，对于这种拥有固定数目的数据成员来说使用std::initialzer-list来改写后，如果列表初始化的参数刚好是3个，则数据成员完全初始化，如果列表初始化的个数小于3个则未给予的值是一个随机值，而大于3个的话超出的列表初始化参数将被抛弃。
       虽然std::initialzer-list可以改写我们自定义的类，但是对于用于固定的数据成员的类来说这种改写意义不大，若列表初始化个数少于数据成员个数则会导致某些数据成员未被初始化，容易引起程序出BUG，BUT如果我们自定义的类也是一个容器类情况呢？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class FooVec
{
public:
    std::vector<int> m_vec;
    FooVec(std::initializer_list<int> list)
    {
        for(auto it = list.begin(); it != list.end(); it++)
        {
            m_vec.push_back(*it);
        }
    }
};
int main()
{
    FooVec foo1 { 1, 2, 3, 4, 5, 6 };
    FooVec foo2 { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    return 0;
}

       可见，用std::initialzer-list改写我们自定义的容器类可以使得我们自定义的容器类和STL中的容器类一样拥有接受可变长相同数据类型的数据的能力，注意数据类型必须相同。std::initialzer-list不仅可以用于自定义类型的列表初始化方法，也可以用于传递相同类型数据的集合：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void func(std::initializer_list<int> list)
{
    for(auto it = list.begin(); it != list.end(); it++)
    {
        cout << *it << endl;
    }
}
int main()
{
    func({});//传递一个空集
    func({ 1, 2, 3 });//传递int类型的数据集
    return 0;
}

       因此在以后碰到需要使用可变长度的同类型的数据时，可以考虑使用std::initialzer-list。

std::initialzer-list的使用细节

       简单了解了initialzer-list后，看看它拥有哪些特点呢？
       1、它是一个轻量级的容器类型，内部定义了迭代器iterator等容器必须的一些概念。
       2、对于initialzer-list来说，它可以接受任意长度的初始化列表，但是元素必须是要相同的或者可以转换为T类型的。
       3、它只有三个成员接口，begin()，end()，size()，其中size()返回initialzer-list的长度。
       4、它只能被整体的初始化和赋值，遍历只能通过begin和end迭代器来，遍历取得的数据是可读的，是不能对单个进行修改的。
       类似下面的操作时不合法的

1
2
3
4
5
6
7
8
9
std::initializer_list<int> list_t ={ 1, 2, 3, 4 };
int main()
{
    for(auto it = list_t.begin(); it != list_t.end; it++)
    {
        (*it) = 1;
    }
    return 0;
}

       此外initialzer-list保存的是T类型的引用，并不对T类型的数据进行拷贝，因此需要注意变量的生存期。比如我们不能这样使用：

1
2
3
4
5
std::initializer_list<int> func(void)
{
    auto a = 2, b = 3;
    return{ a, b };
}

       虽然看起来没有任何问题，且能正常编译通过，但是a，b是在func内定义的局部变量，但程序离开func时变量a，b就销毁了，initialzer-list却保存的是变量的引用，因此返回的将是非法未知的内容。

列表初始化防止类型收窄

       C++11的列表初始化还有一个额外的功能就是可以防止类型收窄，也就是C++98/03中的隐式类型转换，将范围大的转换为范围小的表示，在C++98/03中类型收窄并不会编译出错，而在C++11中，使用列表初始化的类型收窄编译将会报错：

1
2
3
4
5
6
7
8
9
int a = 1.1; //OK
int b{ 1.1 }; //error
float f1 = 1e40; //OK
float f2{ 1e40 }; //error
const int x = 1024, y = 1;
char c = x; //OK
char d{ x };//error
char e = y;//error
char f{ y };//error

       上面例子看出，用C++98/03的方式类型收窄并不会编译报错，但是将会导致一些隐藏的错误，导致出错的时候很难定位，而利用C++11的列表初始化方法定义变量从源头了遏制了类型收窄，使得不恰当的用法就不会用在程序中，避免了某些位置类型的错误，因此建议以后再实际编程中尽可能的使用列表初始化方法定义变量。

本文标题:C++11 新特性之列表初始化

文章作者:Greedysky

发布时间:2017年02月23日 - 20时14分

最后更新:2023年07月21日 - 23时57分

原始链接:https://greedysky.github.io/2017/02/23/C++11新特性之列表初始化/

许可协议: "署名-非商用-相同方式共享 3.0" 转载请保留原文链接及作者。

文章目录
  1. 1. 前言
  2. 2. 统一的初始化方法
  3. 3. 列表初始化的一些使用细节
  4. 4. 初始化列表
    1. 4.1. 任何长度的初始化列表
    2. 4.2. std::initialzer-list的使用细节
  5. 5. 列表初始化防止类型收窄