先说结论，用std::initializer_list初始化vector，内部逻辑是先生成了一个临时数组，进行了拷贝构造，然后用这个数组的起终指针初始化initializer_list。然后再用initializer_list对vector进行初始化，这个动作又触发了拷贝构造。

所以说，用initializer_list初始化，还是有优化空间的。

感觉吧，如果你真想用vector保存对象，减少一半的拷贝动作的方法：最好用vector的emplace_back把数据给move进去，或者原地初始化。

或者，就用vector保存指针

std::vector<std::string> vec1{ "ant", "bat", "cat" };

 运行到initializer_list的构造函数：

D:\DevTools\VS2017\VC\Tools\MSVC\14.16.27023\include\initializer_list

template<class _Elem>
	class initializer_list
	{	// list of pointers to elements
public:
	typedef _Elem value_type;
	typedef const _Elem& reference;
	typedef const _Elem& const_reference;
	typedef size_t size_type;

	typedef const _Elem* iterator;
	typedef const _Elem* const_iterator;

	constexpr initializer_list() noexcept
		: _First(nullptr), _Last(nullptr)
		{	// empty list
		}

	constexpr initializer_list(const _Elem *_First_arg,
		const _Elem *_Last_arg) noexcept
		: _First(_First_arg), _Last(_Last_arg)
		{	// construct with pointers
		}  //。。。。。。。。。。。。。。。。运行到这里。。。。。。。。。。。。。。

..........

};

这个std::initializer_list是怎么个事呢，它就是一个wrapper，一个viewer。注意它的构造函数，接收的是起始指针和末尾的指针。所以std::initializer_list就是保存了起终指针。所以std::initializer_list对象的拷贝，也是属于“浅拷贝”，保存的都是指针，不影响它们指向的数据。

下面的描述，说明了：

https://cplusplus.com/reference/initializer_list/initializer_list/

initializer_list objects are automatically constructed as if an array of elements of type T was allocated, with each of the elements in the list being copy-initialized to its corresponding element in the array, using any necessary non-narrowing implicit conversions.

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 (reference semantics).

The lifetime of this temporary array is the same as the initializer_list object.

通过这个了例子，说明了初始化initializer_list所用的起终指针，是来自于一个
“数组”，这个数组提前被拷贝构造函数初始化过了。相当于先进行了三次拷贝动作。

class MyDate
{
public:
    MyDate()//构造函数
    {
        std::cout << "构造函数 this地址 " << this << std::endl;
    }

    ~MyDate()//析构函数
    {
        std::cout << "析构函数" << std::endl;
    }
    MyDate(std::initializer_list<MyDate>& d)//initializer_list拷贝构造函数
    {
        std::cout << "initializer_list拷贝构造函数" << std::endl;
    }
    MyDate(const MyDate& d)//拷贝构造函数
    {
        std::cout << "/拷贝构造函数 scr地址 " << &d << std::endl;
        std::cout << "拷贝构造函数 this地址 " << this << std::endl;
    }

    MyDate& operator=(const MyDate& d)//赋值运算符重载
    {
        std::cout << "赋值运算符重载" << std::endl;
        return *this;
    }

    MyDate* operator&()//取地址运算符重载（&）
    {
        std::cout << "取地址运算符重载（&）" << std::endl;
        return this;
    }

    const MyDate* operator&() const//const修饰的取地址运算符重载（const &）
    {
        //std::cout << "const修饰的取地址运算符重载（const &）" << std::endl;
        return this;
    }

    int val;
};

int main()
{
构造函数 this地址 000000000014F1C4
        MyDate d0; 

        std::cout << "d0 already initialized" << std::endl;
        std::cout <<  std::endl;

/拷贝构造函数 scr地址 000000000014F1C4  “看地址，说明用d0进行的初始化”
拷贝构造函数 this地址 000000000014F1E4
        MyDate d1{ d0};

        std::cout << "d1 already initialized" << std::endl;
        std::cout << std::endl;

打印信息
//拷贝构造函数 scr000000000014F1C4 “看地址，说明用d0进行的初始化”
拷贝构造函数 this000000000014FDA8
/拷贝构造函数 scr000000000014F1C4 “看地址，说明用d0进行的初始化”
拷贝构造函数 this000000000014FDAC
/拷贝构造函数 scr000000000014F1C4 “看地址，说明用d0进行的初始化”
拷贝构造函数 this000000000014FDB0

解释：
初始化了一个长度为3的“临时”数组，用d0进行了三次构造拷贝动作，数组中每个对象的地址分别为
000000000014FDA8
000000000014FDAC
000000000014FDB0

紧接着打印：
/拷贝构造函数 scr地址 000000000014FDA8
拷贝构造函数 this地址 00000000005E3660
/拷贝构造函数 scr地址 000000000014FDAC
拷贝构造函数 this地址 00000000005E3664
/拷贝构造函数 scr地址 000000000014FDB0
拷贝构造函数 this地址 00000000005E3668

解释：
这些打印信息，是把临时数组里的对象拷贝进了vector里：
vector(initializer_list<_Ty> _Ilist, const _Alloc& _Al = _Alloc())
		: _Mybase(_Al)
		{	// construct from initializer_list, optional allocator
		_Range_construct_or_tidy(_Ilist.begin(), _Ilist.end(), random_access_iterator_tag{});
		}

        std::vector < MyDate> d2{ d0,d0,d0 };


//std::vector < MyDate> d2{ d0,d0,d0 };这段代码相当于：
//std::vector<MyDate> dt;
//dt.reserve(3);
//dt.emplace_back(d0);
//dt.emplace_back(d0);
//dt.emplace_back(d0);
//std::initializer_list lst(dt.begin(), dt.end());
//std::vector < MyDate> d2(lst); //对vector用initializer_list进行初始化

        return 1;
}