---

一、概念辨析

1. 声明、定义、初始化、赋初值的概念

四个易混淆的概念：声明，定义，初始化，赋初值

1. 声明：声明一个变量或函数，表示告诉编译器这个变量或函数的类型和名称。对于变量，声明并不分配内存。对于函数，声明告诉编译器函数的名称，返回类型和参数列表。
2. 定义：对于变量，定义表示分配内存，但不必赋予初值。对于函数，定义是提供函数的实体或主体。在整个工程中，同一个变量只能被定义一次，但可以被声明无数次。
3. 初始化：初始化是定义变量的过程中给它赋予一个初始值。初始化是定义和赋初值的组合过程。
4. 赋初值：也是指为变量赋予初次的值，通常与初始化交互使用。

---

初始化 = 定义 + 赋初值

因此，初始化不等于赋值，初始化的含义是创建变量时赋予其一个初始值，而赋值的含义是把对象的当前值擦除，而以一个新值来替代。

2. 默认初始化 和 未被初始化 的概念

如果定义变量时没有指定初值，则变量被默认初始化（default initialized）：

int a;

此时a变量被赋予了“默认值”。默认值到底是什么由变量类型决定，同时定义变量的位置也会对此有影响。如果是内置类型的变量未被显式初始化，它的值由定义的位置决定：

• 定义于任何函数体之外（全局） 的变量被初始化为 0，被称为零初始化（zero initialization）（静态变量是个例外） 。
• 定义在函数体内部的内置类型变量将不被初始化（ uninitialized ）。

一个未被初始化的内置类型变量的值是未定义的（可以理解为随机值）。

---

二、C++98 的列表初始化

在C++98中，标准允许使用花括号 { } 对：

1. 内置类型
2. 数组
3. 结构体元素
   来进行统一的列表初始值设定。比如：

struct Point
{
	int _x;
	int _y;
};
int main()
{
	//C++98
	
	// 变量
	int a1 = 1;
	int a2 = { 2 };
	
	// 数组
	int array1[] = { 1, 2, 3, 4, 5 };
	int array2[5] = { 0 };
	
	// 自定义类型
	Point p = { 1, 2 };
	return 0;
}

三、C++11 对列表初始化的扩展（统一初始化）

C++11扩大了用初始化列表 { } 的使用范围，这是语法（语言内核）层面上的修改，使其可用于所有的内置类型和用户自定义的类型，使用初始化列表时，可添加等号(=)，也可不添加：

struct Point
{
	int _x;
	int _y;
};
int main()
{
	//C++11
	
	// 变量和数组
	int a3{ 3 };
	int a4(4);
	int array1[]{ 1, 2, 3, 4, 5 };
	int array2[5]{ 0 };

	// 自定义类型
	Point p{ 1, 2 };

	// C++11中列表初始化也可以适用于new表达式中
	int* pa = new int[4] { 0 };


	return 0;
}

创建对象时也可以使用列表初始化方式调用构造函数初始化：

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

int main()
{
	Date d1(2022, 1, 1); // old style
	// C++11支持的列表初始化，这里会调用构造函数初始化
	Date d2{ 2022, 1, 2 };
	Date d3 = { 2022, 1, 3 };
	return 0;
}

四、标准库中的 initializer_list 类

在C++11标准下，下面的il的类型是什么？

int main()
{
	// the type of il is an initializer_list
	auto il = { 10, 20, 30 };
	cout << typeid(il).name() << endl;
	return 0;
}

发现是std::initializer_list：

介绍：

• initializer_list 是一个特殊的模板类，用于表示一个初始化列表。
• 它允许以逗号分隔的值列表的形式来初始化对象，例如：

  `std::initializer_list<int> myList = {1, 2, 3};`
  

• 通常用于容器的构造函数，例如：

  std::vector<int> myVector = {1, 2, 3};
  

说明一下：

---

在官方文档对initializer_list的介绍中，有这样一段话：

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).

这句话的意思是，initializer_list 对象引用数组的元素，但并不包含这些元素的实际副本。复制一个 initializer_list 对象会产生另一个对象，它引用相同的底层元素，而不是这些元素的新副本。这是因为 initializer_list 的语义是基于引用语义而不是值语义。


让我们通过一个简单的例子来理解：

#include <iostream>
#include <initializer_list>

void printValues(std::initializer_list\<int> values) 
{
   for (auto value : values) 
   {
       std::cout << value << " ";
   }
   std::cout << std::endl;
}

int main() {
   int arr[] = {1, 2, 3};
   
   // 使用 initializer_list 对象初始化
   std::initializer_list<int> myList = {arr[0], arr[1], arr[2]};
   
   // 复制 initializer_list 对象
   std::initializer_list<int> myCopy = myList;

   // 修改原始数组
   arr[0] = 10;

   // 打印两个 initializer_list 对象
   printValues(myList);   // 输出: 1 2 3
   printValues(myCopy);   // 输出: 10 2 3

   return 0;
}

在上面的例子中，myList 和 myCopy 都是 initializer_list 对象，它们引用相同的底层数组 {1, 2, 3}。当我们修改原始数组中的值时，这种变化会反映在两个 initializer_list 对象中，因为它们只是引用相同的元素，而不是拥有它们的副本。

这种引用语义有助于减少不必要的内存开销，因为不会为每个 initializer_list 创建新的元素副本。

所以在语句 std::initializer_list<int> myList = {1, 2, 3}; 中，myList 不会复制一份自己的1、2、3，而只会引用列表中这些常量。实际上，initializer_list 只包含指向初始化列表中元素的指针和大小信息，而不会拥有列表中的元素。

这些常量元素通常存放在程序的常量/代码区，而 initializer_list 对象本身只是一个轻量级的包装器，用于提供一个方便的接口来访问初始化列表中的元素。

---

五、正确理解“统一初始化”和 initializer_list 的区别

• initializer_list 是 C++ 标准库提供的一种机制，用于方便地处理初始化列表。它是一个模板类，允许以统一初始化语法（花括号 {}）的形式传递元素列表给对象。initializer_list 提供了一个简单的接口，使得在标准库中的容器或其他类的构造函数中能够方便地接受初始化列表。

• 统一初始化语法是 C++11 引入的一项语法改进，使得初始化更加简洁和一致。它允许使用花括号 {} 初始化各种类型的对象，包括数组、结构体、类和容器等。在使用统一初始化语法时，编译器会自动选择合适的构造函数，这也包括 initializer_list 的构造函数。

因此，initializer_list 和统一初始化语法是在不同层次上的概念！！！initializer_list 是标准库提供的一种机制，而统一初始化是一种语法特性。

---

六、initializer_list 的使用场景

vector 的列表初始化

vector<string> articles = {"a", "an", "the"}; // 正确
vector<string> articles{"a", "an", "the"};    // 正确
vector<string> articles("a", "an", "the");    // 错误

这行代码是使用 C++11 的统一初始化语法来初始化一个 std::vector 对象，其中 std::initializer_list<string> 作为构造函数的参数。这样的初始化方式使得代码更加简洁和直观。

{"a", "an", "the"} 被编译器视作一个初始化列表，且被编译器转换成了std::initializer_list<string>。这个initializer_list被传递给 std::vector<string> 的构造函数，该构造函数的原型如下：

explicit vector (initializer_list<value_type> il, const allocator_type& alloc = allocator_type());

这种方式相较于传统的构造方式：

vector<string> articles;
articles.push_back("a");
articles.push_back("an");
articles.push_back("the");

具有更简洁的语法，提高了代码的可读性，并且利用了新引入的统一初始化语法。

当然vector的拷贝赋值函数也拥有了对initializer_list的重载版本：

vector& operator= (initializer_list<value_type> il);

pair 的列表初始化

std::pair 的成员（first 和 second）通过花括号 {} 进行列表初始化：

#include <iostream>
#include <utility> // 包含头文件以使用 std::pair
#include <map>

int main() 
{
    std::pair<int, std::string> myPair = {42, "Hello"};

    std::cout << "Pair: {" << myPair.first << ", " << myPair.second << "}\n";

    return 0;
}

关联式容器的列表初始化

以 std::map 为例：

#include <iostream>
#include <map>

int main() {
    std::map<std::string, std::string> dict = {{"sort", "排序"}, {"insert", "插入"}};

    // 输出所有键值对
    for (const auto& entry : dict) 
    {
        std::cout << "Key: " << entry.first 
                  << ", Value: " << entry.second << "\n";
    }

    return 0;
}

---

七、让模拟实现的vector也支持{}初始化和赋值

namespace chen
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;
		typedef ReverseIterator<iterator, T&, T*> reverse_iterator;
		typedef ReverseIterator<const_iterator, const T&, const T*> const_reverse_iterator;
	public:
		// 构造和析构
		vector()
		{
			std::cout << "构造" << std::endl;
		}
		
		vector(initializer_list<T> il)
		{
			size_t sz = il.size();
			auto it = il.begin();
			reserve(sz);
			for (size_t i = 0;i < sz;i++, it++)
			{
				_start[i] = *it;
			}
			_finish = _start + sz;
		}
		
		void swap(vector<T>&& v)
		{
			std::swap(this->_start, v._start);
			std::swap(this->_finish, v._finish);
			std::swap(this->_endofstorage, v._endofstorage);
		}
		
		// 赋值运算符重载
		chen::vector<T>& operator=(chen::vector<T>& tmp)
		{
			this->swap(tmp);
			return *this;
		}
		
		// 赋值运算符重载 - 列表初始器版本
		chen::vector<T>& operator=(initializer_list<T> il) 
		{
			chen::vector<T> tmp(il);
			std::swap(_start, tmp._start);
			std::swap(_finish, tmp._finish);
			std::swap(_endofstorage, tmp._endofstorage);
			return *this;
		}
		
	private:
		iterator _start = nullptr;        // 开始位置
		iterator _finish = nullptr;       // 最后一个有效位置的下一个位置
		iterator _endofstorage = nullptr; // 开辟总空间最后一个有效位置的下一个位置
	};
}

完整vector实现链接：博主的STL模拟实现