列表初始化（1）_统一初始化

#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对象，再调用拷贝构造函数（后面这步可能被优化）
    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>的构造函数时，编译器会找到一个接受initializer_list<string>
    //的重载的构造函数。所有的容器均有这样的构造函数。在这个构造函数里会利用
    //initializer_list<string>来初始化。
    vector<string> city{"Berlin", "New York", "London", "Cairo","Tokyo", "Cologne"};
    
    //编译器会为以下花括号形成一个initializer_list<double>，背后有个array<double,2>。
    //调用complex<double>的构造函数时，array内的2个元素被分解并传给
    //Comlex<double>(double,double)这个带有两个参数的构造函数。因为comlex<double>并无
    //任何接受initializer_list的构造函数。
    complex<double> c{4.0, 3.0}; //等价于c(4.0, 3.0)
    
    return 0;
}

#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;   //元素的个数
    
    //编译器可以调用private的构造函数！！！
    //构造函数，在调用之前，编译会先在外部准备好一个array，同时把array的地址传入模板
    //并保存在_M_array中
    constexpr initializer_list(const_iterator __a, size_type __l)
    :_M_array(__a),_M_len(__l){};  //注意构造函数被放到private中！

    constexpr initializer_list() : _M_array(0), _M_len(0){} // empty list，无参构造函数
    
    //size()函数，用于获取元素的个数
    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;
    }  
};

#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>采用的是浅拷贝，当
                   //函数返回后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
*/

#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;
public:
    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)函数，以下3种方
    //式的初始化都会将{...}作为一个整体传递给该函数。如果没有定义该函
    //数，则由于该类是个非聚合类用{}初始化时，会调用构造函数来初始化。
    //但由于Foo类不存在3个参数的构造函数，所以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
Foo(initializer_list<int> list) : 77 5
{1,2} {3,4} {5,6}
*/