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

時間 2020-05-04

原文原文鏈接

C++11新增了列表初始化的概念。c++

在C++11中能夠直接在變量名後面加上初始化列表來進行對象的初始化。數組

struct A {
public:
    A(int) {}
private:
    A(const A&) {}
};
int main() {
    A a(123);
    A b = 123; // error
    A c = { 123 };
    A d{123}; // c++11

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

    return 0;
}複製代碼

列表初始化也能夠用在函數的返回值上ide

std::vector<int> func() {
    return {};
}複製代碼

列表初始化的一些規則：函數

首先說下聚合類型能夠進行直接列表初始化，這裏須要瞭解什麼是聚合類型：優化

類型是一個普通數組，如int[5]，char[]，double[]等spa
類型是一個類，且知足如下條件：.net
- 沒有用戶聲明的構造函數
- 沒有用戶提供的構造函數(容許顯示預置或棄置的構造函數)
- 沒有私有或保護的非靜態數據成員
- 沒有基類
- 沒有虛函數
- 沒有{}和=直接初始化的非靜態數據成員
- 沒有默認成員初始化器

struct A {
    int a;
    int b;
    int c;
    A(int, int){}
};
int main() {
    A a{1, 2, 3};// error，A有自定義的構造函數，不能列表初始化
}複製代碼

上述代碼類A不是聚合類型，沒法進行列表初始化，必須以自定義的構造函數來構造對象。c++11

struct A {
    int a;
    int b;
    virtual void func() {} // 含有虛函數，不是聚合類
};

struct Base {};
struct B : public Base { // 有基類，不是聚合類
      int a;
    int b;
};

struct C {
    int a;
    int b = 10; // 有等號初始化，不是聚合類
};

struct D {
    int a;
    int b;
private:
    int c; // 含有私有的非靜態數據成員，不是聚合類
};

struct E {
      int a;
    int b;
    E() : a(0), b(0) {} // 含有默認成員初始化器，不是聚合類
};複製代碼

上面列舉了一些不是聚合類的例子，對於一個聚合類型，使用列表初始化至關於對其中的每一個元素分別賦值；對於非聚合類型，須要先自定義一個對應的構造函數，此時列表初始化將調用相應的構造函數。code

std::initializer_list對象

咱們平時開發使用STL過程當中可能發現它的初始化列表能夠是任意長度，你們有沒有想過它是怎麼實現的呢，答案是std::initializer_list，看下面這段示例代碼：

struct CustomVec {
    std::vector<int> data;
    CustomVec(std::initializer_list<int> list) {
        for (auto iter = list.begin(); iter != list.end(); ++iter) {
            data.push_back(*iter);
        }
    }
};複製代碼

我想經過上面這段代碼你們可能已經知道STL是如何實現的任意長度初始化了吧，這個std::initializer_list其實也能夠做爲函數參數。

注意：std::initializer_list ，它能夠接收任意長度的初始化列表，可是裏面必須是相同類型T，或者均可以轉換爲T。

列表初始化的好處

我的認爲列表初始化的好處以下：

方便，且基本上能夠替代括號初始化
可使用初始化列表接受任意長度
能夠防止類型窄化，避免精度丟失的隱式類型轉換

什麼是類型窄化，列表初始化經過禁止下列轉換，對隱式轉化加以限制：

從浮點類型到整數類型的轉換
從 long double 到 double 或 float 的轉換，以及從 double 到 float 的轉換，除非源是常量表達式且不發生溢出
從整數類型到浮點類型的轉換，除非源是其值能徹底存儲於目標類型的常量表達式
從整數或無做用域枚舉類型到不能表示原類型全部值的整數類型的轉換，除非源是其值能徹底存儲於目標類型的常量表達式

示例：

int main() {
    int a = 1.2; // ok
    int b = {1.2}; // error

    float c = 1e70; // ok
    float d = {1e70}; // error

    float e = (unsigned long long)-1; // ok
    float f = {(unsigned long long)-1}; // error
    float g = (unsigned long long)1; // ok
    float h = {(unsigned long long)1}; // ok

    const int i = 1000;
    const int j = 2;
    char k = i; // ok
    char l = {i}; // error

    char m = j; // ok
    char m = {j}; // ok，由於是const類型，這裏若是去掉const屬性，也會報錯
}複製代碼

打印以下：

test.cc:24:17: error: narrowing conversion of ‘1.2e+0’ from ‘double’ to ‘int’ inside { } [-Wnarrowing]
     int b = {1.2};
                 ^
test.cc:30:38: error: narrowing conversion of ‘18446744073709551615’ from ‘long long unsigned int’ to ‘float’ inside { } [-Wnarrowing]
     float f = {(unsigned long long)-1};
                                      ^
test.cc:36:14: warning: overflow in implicit constant conversion [-Woverflow]
     char k = i;
              ^
test.cc:37:16: error: narrowing conversion of ‘1000’ from ‘int’ to ‘char’ inside { } [-Wnarrowing]
     char l = {i};複製代碼

關於列表初始化的全部知識點就是這些，若有遺漏或者遺漏的你們積極留言哈，請持續關注~