C++11统一列表初始化，initializer_list

目录

1.C++11统一了列表的初始化

2.initializer_list

3.initializer_list是如何支持的

---

1.C++11统一了列表的初始化

现在无论内置类型和自定义类型都可以用列表初始化。

class Date
{
 public:
  Date(int year, int month, int day)
   :_year(year)
   ,_month(month)
   ,_day(day) 
  {}
  
 private:
  int _year;
  int _month;
  int _day;
}

int main()
{
    int x = 0;//之前初始化
    int y = {1}//c++11初始化
    int z {2}//c++11初始化    
    vector<int> v1 = {1,2,3,4,5};//c++11初始化  
    vector<int> v2 {1,2,3,4,5};//c++11初始化  
    Date day1(2004,02,06);//c++98
    Date day2{2004,02,06};//c++11
    Date day3 = {2004,02,06};//c++11
    //new也支持用列表初始化
    int * pa = new int[4]{1,2,3,4}
  
    return 0;
}

2.initializer_list

vector之所以能向上面那样写，是因为c++11引入了initializer_list，用initializer_list作为参数，进行重载了一个构造函数。

This type is used to access the values in a C++ initialization list, which is a list of elements of type const T.

这个类型被用于访问C++的初始化列表，这个列表的的元素类型是const T。

包含<initializer_list>头文件就可以使用initializer_list

auto lt  = {1,2,3,4,5}

这个lt的类型就是 initializer_list，就是用来接收{1,2,3,4,5}。

The initializer_list object refers to the elements of this array without containing them: copying an initializer_list object produces another object referring to the same underlying elements, not to new copies of them。

initializer_list对象引用数组的元素，但是并不包含他们，拷贝一个initializer_list的对象，产生的另一个对象，底层引用相同的元素，不是新拷贝一份。

如果参数是列表，myclass(initializer_list<int> lt);会被优先调用。

struct myclass
{
  myclass(int a,int b);
  myclass(initializer_list<int> lt);
};

int mian()
{
 myclass s1(1,1)//myclass(int a,int b)
 myclass s2{1,1}// myclass(initializer_list<int> lt)
 return 0;
}

3.initializer_list是如何支持的

这里拿vector举例

template<class T>
	class vector
	{
	public:
		typedef T* iterator;

		vector()
		{}
		vector(const initializer_list<T>& lt)
		{
			cout << "	vector(const initializer_list<T>& lt)" << endl;
			_start = new T[lt.size()];
			_finsh = _start + lt.size();
			_endofstorage  = _start + lt.size();
			iterator vit = _start;

			for (auto it : lt)
			{
				*vit++ = it;
			}
			
		}

		vector& operator=(const initializer_list<T>& lt)
		{
			cout << "vector& operator=(const initializer_list<T>& lt)" << endl;
			vector<T> tmp(lt);
			std::swap(_start,tmp._start);
			std::swap(_finsh,tmp._finsh);
			std::swap(_endofstorage,tmp._endofstorage);
			return *this;
	    }

	private:
		T* _start;
		T* _finsh;
		T* _endofstorage;
	};