C++11之初始化成员变量

C++98中的成员变量初始化

• 在声明类的时候，对于静态类型并且是常量类型，同时是枚举或者是整型的变量可以使用=在声明时初始化。
• 对于不符合上述要求的静态变量可以在类外使用=进行初始化
• 对于非静态类型可以说个初始化列表进行初始化
• 使用（）对自定义类型进行初始化
• 使用{}对元素集合统一初始化

C++11中的成员变量初始化

在C++11中可以使用=或者{}就地初始化，类似于Java语言。
代码示例

struct init{
    int a  = 1;
    double b{1.2};
};

需要注意的是（）不能与=和{}有相同的使用方式，代码示例

#include<iostream>
using namspace std;

struct C
{
    C(int i):c(i){};
    int  c;
};

struct init
{
    int a = 1;
    string b("test");//编译通不过
    C c(1);          //编译通不过
};

需要注意的是=和{}可以和初始化列表一起使用，而且初始化列表总是后作用于=和{}

C++11丰富{}初始化

使用{}丰富化向量初始化，代码示例

#include<vector>
#include<map>
using namespace std;

int a[] = {1. 3. 5};
int b[] {2. 4. 6};
vector<int> c{1, 3, 5};
map<int, float> d = {{1, 1.0f}, {2, 2.0f}, {3, 3.0f}};
int f = {3 + 4};
int g(3 + 4);            //可以与new结合用来申请堆内存
int h{3 + 4};            //可以与new结合用来申请堆内存

以上代码在C++11中可以顺利通过编译，但是在C++98中确不可以通过编译。可以发现上面的代码的初始化列表仅在基本类型和stl元素可以使用，对于那些自定义类型，可以通过修改构造函数、重载运算符等操作。

示例代码

#include<iostream>
#include<vector>

using namespace std;

class Mydata{
public:
    Mydata& operator[] (initializer_list<int> l)
    {
        for(auto i = l.begin(); i != l.end(); i++)
            idx.push_back(*i);
        return *this;
    }

    Mydata& operator = (int v)
    {
        for(auto i = idx.begin(); i != idx.end(); i++)
        {
            d.resize((*i > d.size())? *i: d.size());
            d[*i - 1] = v;
            cout << v << endl;
        }
        idx.clear();

        return *this;
    }

    void print()
    {
        for(auto i = d.begin(); i != d.end(); i++)
            cout << *i << "   " ;
    }
private:
    vector<int> idx;
    vector<int> d;
};

int main()
{
    Mydata d;
    d[{2, 3, 5}] = 90;
    d[{1, 4, 5, 8}] = 7;
    d.print();
    return 0;

}

{}初始化列表的优点

与其他的初始化方式相比，{}初始化是唯一一种可以防止类型收窄的初始化方式。所谓的类型收窄其实就是新类型不可以表示原来类型的情况，在类型转换的过程中数据丢失。
示例代码

#include<iostream>
using namespace std;


int main()
{
    const int x = 1024;
    const int y = 10;

    char a = x;       //收窄，编译可以通过
    char *b = new char(1024);//收窄，编译可以通过

    char c = {x};   //收窄，编译可以通过
    char d = {y};   //编译可以通过
    unsigned char e {-1}; //收窄，编译无法通过

    float f{ 7 }; //编译可以通过
    int g { 2.0f };       //收窄，编译无法通
    float *h = new float{1e48};  //收窄，编译无法通
    float i = 1.2l; //可以通过编译

    return 0;
}

参考链接
C++11中新特性之：initializer_list详解