C++11中跳轉initializer_list怎么實現(xiàn)

本篇內容介紹了“C++11中跳轉initializer_list怎么實現(xiàn)”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！

1.初始化列表的實現(xiàn)

（1）當編譯器看到{t1,t2&hellip;tn}時便會生成一個initializer_list<T>對象（其中的T為元素的類型），它關聯(lián)到一個array<T,n>。

（2）對于聚合類型，編譯器會將array<T,n>內的元素逐一分解并賦值給被初始化的對象。這相當于為該對象每個字段分別賦值。

（3）對于非聚合類型。如果該類存在一個接受initializer_list<T>類型的構造函數(shù)，則初始化時會將initializer_list<T>對象作為一個整體傳給構造函數(shù)。如果不存在這樣的構造函數(shù)，則array內的元素會被編譯器分解并傳給相應的能接受這些參數(shù)的構造函數(shù)（比如列表中有2個元素的，就傳給帶2個參數(shù)的構造函數(shù)。有3個元素的，就傳給帶3個參數(shù)的構造函數(shù)，依此類推&hellip;&hellip;）。

【實例分析】initializer_list<T>初體驗

#include <iostream>
#include <vector>
#include <map>
#include <complex>
using namespace std;
//編譯選項：g++ -std=c++11 test1.cpp -fno-elide-constructors
class Foo
{
public:
    Foo(int)
    {
        cout << "Foo(int)"<< endl;
    }
    
    Foo(int, int)
        cout << "Foo(int, int)"<< endl;
    Foo(const Foo& f)
        cout << "Foo(const Foo& f)"<< endl;
};
int main()
    Foo f1(123);
    Foo f2 = 123;   //先將調用Foo(int)將123轉為Foo對象，再調用拷貝構造函數(shù)（后面這步可能被優(yōu)化）
    Foo f3 = {123}; //生成initializer_list<int>，然后分解元素后，由于列表中只有1個元素，所以將其傳給Foo(int)
    Foo f4 = {123, 321}; //生成initializer_list<int>，然后分解元素后，由于列表中有兩個元素，所以將其傳給Foo(int, int)
    //編譯器會為以下花括號形成一個initializer_list<string>，背后有個array<string,6>
    //調用vector<string>的構造函數(shù)時，編譯器會找到一個接受initializer_list<string>
    //的重載的構造函數(shù)。所有的容器均有這樣的構造函數(shù)。在這個構造函數(shù)里會利用
    //initializer_list<string>來初始化。
    vector<string> city{"Berlin", "New York", "London", "Cairo","Tokyo", "Cologne"};
    //編譯器會為以下花括號形成一個initializer_list<double>，背后有個array<double,2>。
    //調用complex<double>的構造函數(shù)時，array內的2個元素被分解并傳給
    //Comlex<double>(double,double)這個帶有兩個參數(shù)的構造函數(shù)。因為comlex<double>并無
    //任何接受initializer_list的構造函數(shù)。
    complex<double> c{4.0, 3.0}; //等價于c(4.0, 3.0)
    return 0;
}

2. initializer_list<T>模板

//initializer_list<T>源碼分析

#include <iostream>
template <class T>
class initializer_list
{
public:
    typedef T         value_type;
    typedef const T&  reference; //注意說明該對象永遠為const，不能被外部修改！
    typedef const T&  const_reference;
    typedef size_t    size_type;
    typedef const T*  iterator;  //永遠為const類型
    typedef const T*  const_iterator;
private:
    iterator    _M_array; //用于存放用{}初始化列表中的元素
    size_type   _M_len;   //元素的個數(shù)
    
    //編譯器可以調用private的構造函數(shù)！?。?
    //構造函數(shù)，在調用之前，編譯會先在外部準備好一個array，同時把array的地址傳入模板
    //并保存在_M_array中
    constexpr initializer_list(const_iterator __a, size_type __l)
    :_M_array(__a),_M_len(__l){};  //注意構造函數(shù)被放到private中！
    constexpr initializer_list() : _M_array(0), _M_len(0){} // empty list，無參構造函數(shù)
    //size()函數(shù)，用于獲取元素的個數(shù)
    constexpr size_type size() const noexcept {return _M_len;}
    //獲取第一個元素
    constexpr const_iterator begin() const noexcept {return _M_array;}
    //最后一個元素的下一個位置
    constexpr const_iterator end() const noexcept
    {
        return begin() + _M_len;
    }  
};

（1）initializer_list是一個輕量級的容器類型，內部定義了iterator等容器必需的概念，本質上是一個迭代器！

（2）對于std:: initializer_list<T>而言，它可以接收任意長度的初始化列表，但要求元素必須是同種類型（T或可轉換為T）。

（3）它有3個成員函數(shù)：size()、begin()和end()。

（4）擁有一個無參構造函數(shù)，可以被直接實例化，此時將得到一個空的列表。之后可以進行賦值操作，如initializer_list<int> list; list={1,2,3,4,5};

（5）initializer_list<T>在進行復制或賦值時，它內部將保存著列表的地址保存在_M_array中，它進行的是淺拷貝，并不真正復制每個元素，因此效率很高。

【編程實驗】打印初始化列表的每個元素

#include <iostream>
//打印初始化列表的每個元素
void print(std::initializer_list<int> vals)
{
    //遍歷列表中的每個元素
    for(auto p = vals.begin(); p!=vals.end(); ++p){
        std::cout << *p << " ";
    }
    
    std::cout << std::endl;
}
//std::initializer_list<T>的淺拷貝。以下的返回值應改為std
//以下的返回值應改為std::vector<int>類型，而不是std::initializer_list<int>類型。
std::initializer_list<int> func(void)
    int a = 1;
    int b = 2;
    return {a, b}; //編譯器看到{a, b}時，會做好一個array<int,2>對象（其生命
                   //期直至func結束），然后再產生一個initializer_list<int>
                   //臨時對象，由于initializer_list<int>采用的是淺拷貝，當
                   //函數(shù)返回后array<int,2>會被釋放，所以無法獲取到列表中的元素！
int main()
    print({1,2,3,4,5,6,7,8,9,10});
    print(func());
    return 0;
/*測試結果：
e:\Study\C++11\7>g++ -std=c++11 test1.cpp
e:\Study\C++11\7>a.exe
1 2 3 4 5 6 7 8 9 10
*/

3.讓自定義的類可以接受任意長度初始化列表

（1）自定義類中重載一個可接受initializer_list<T>類型的構造函數(shù)

（2）在該構造函數(shù)中，遍歷列表元素并賦值給相應的字段。

【編程實驗】自定義類的初始化列表

#include <iostream>
#include <map>
using namespace std;
class Foo
{
public:
    Foo(int a, int b)
    {
        cout << "Foo(int a, int b)" << endl;
    }
    
    Foo(initializer_list<int> list)
        cout << "Foo(initializer_list<int> list) : ";
        
        for(auto i : list){
            cout <<i<< " ";
        }
        cout << endl;
};
class FooMap
    std::map<int, int> content;
    using pair_t = std::map<int, int>::value_type;
    FooMap(std::initializer_list<pair_t> list)
        for(auto it = list.begin(); it!=list.end(); ++it){
            content.insert(*it);
            
            std::cout << "{" << (*it).first <<"," <<(*it).second <<"}" << " ";
        std::cout << std::endl;
int main()
    Foo f1(77, 5);     //Foo(int a, int b), a = 77, b = 5;
    //注意：由于定義了Foo(initializer_list<int> list)函數(shù)，以下3種方
    //式的初始化都會將{...}作為一個整體傳遞給該函數(shù)。如果沒有定義該函
    //數(shù)，則由于該類是個非聚合類用{}初始化時，會調用構造函數(shù)來初始化。
    //但由于Foo類不存在3個參數(shù)的構造函數(shù)，所以f3那行會編譯失??！
    Foo f2{77, 5};     //Foo(initializer_list<int> list)
    Foo f3{77, 5, 42}; //Foo(initializer_list<int> list)
    Foo f4 = {77, 5};  //Foo(initializer_list<int> list)
    FooMap fm = {{1,2}, {3,4},{5,6}};
    return 0;
}
/*測試結果：
e:\Study\C++11\7>g++ -std=c++11 test2.cpp
e:\Study\C++11\7>a.exe
Foo(int a, int b)
Foo(initializer_list<int> list) : 77 5
Foo(initializer_list<int> list) : 77 5 42
{1,2} {3,4} {5,6}
*/

“C++11中跳轉initializer_list怎么實現(xiàn)”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業(yè)相關的知識可以關注億速云網(wǎng)站，小編將為大家輸出更多高質量的實用文章！