【C++进阶】C++11新特性上篇（万字详解）

﹏ヽ暗。殇╰゛Y 2024-04-20 06:34 0阅读 0赞

> **🎇C++学习历程：入门**
> 
> --------------------
> 
>  *  **博客主页：**[一起去看日落吗][Link 1]
>  *  **持续分享博主的C++学习历程**
>  *  **`博主的能力有限，出现错误希望大家不吝赐教`**
>  *  **分享给大家一句我很喜欢的话：** 也许你现在做的事情，暂时看不到成果，但不要忘记，树🌿成长之前也要扎根，也要在漫长的时光🌞中沉淀养分。静下来想一想，哪有这么多的天赋异禀，那些让你羡慕的优秀的人也都曾默默地翻山越岭🐾。
> 
> --------------------
> 
> ![在这里插入图片描述][eabca17da9704379a5f15832a495b4cc.jpeg_pic_center]

♠️ ♥️ ♣️ ♦️

#### 目录 ####

*  ♠️ 1. C++11简介
 *  ♠️ 2. 列表初始化
 *   *  ♥️ 2.1 \{\} 初始化
     *  ♥️ 2.2 std::initializer\_list
 *  ♠️ 3. 声明
 *   *  ♥️ 3.1 auto
     *  ♥️ 3.2 decltype
     *  ♥️ 3.3 nullptr
 *  ♠️ 4. STL中一些变化
 *  ♠️ 5. final 和 override
 *  ♠️ 6. 右值引用和移动语义
 *   *  ♥️ 6.1 左值引用和右值引用
     *  ♥️ 6.2 左值引用和右值引用比较
     *  ♥️ 6.3 右值引用使用场景和意义
     *  ♥️ 6.4 左值引用使用场景
     *  ♥️ 6.4 左值引用短板
     *  ♥️ 6.5 右值引用和移动语义解决上述问题
     *  ♥️ 6.6 STL容器插入接口函数也增加了右值引用版本

## ♠️ 1. C++11简介 ##

相比C++98/03，C++11则带来了数量可观的变化，其中包含了约140个新特性，以及对C++03标准中约600个缺陷的修正，这使得C++11更像是从C++98/03中孕育出的一种新语言。相比较而言，**C++11能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全，不仅功能更强大，而且能提升程序员的开发效率。**

## ♠️ 2. 列表初始化 ##

### ♥️ 2.1 \{\} 初始化 ###

*  在C++98中，标准允许使用花括号\{\}对数组元素进行统一的列表初始值设定。

struct Point
    {
        
     	int _x;
     	int _y;
    };
    int main()
    {
        
     	int array1[] = {
         1, 2, 3, 4, 5 };
     	int array2[5] = {
         0 };  //0 0 0 0 0 
     	Point p = {
         1, 2 };  //运用了struct结构体的语法     初始化
     	return 0; 
     }

*  C++11扩大了用大括号括起的列表(初始化列表)的使用范围，使其可用于所有的内置类型和用户自定义的类型，使用初始化列表时，可添加等号(=)，也可不添加。

struct Point
    {
        
    	int _x;
    	int _y;
    
    	Point(int x, int y)
    		:_x(x)
    		, _y(y)
    	{
        }
    };
    
    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()
    {
        
    	
    	Point p = {
         1, 2 };
    	//Point p{ 1, 2 };
    	
    	Point* p3 = new Point[3]{
         {
        1, 1}, {
         2, 2 }, {
         3, 3 } };
    
    	int* p1 = new int(0);
    	int* p2 = new int[5]{
        1,2,3,4,5};  
    	//C++11中 new可以初始化数组
    
    	//自定义类型的列表初始化
    	Date d1(2022, 3, 13);
    	Date d2 = {
         2022, 3, 15 };
    	Date d3{
         2022, 3, 15 };
    	Date{
        2022,3,15};
    
    	int i = 1;
    	int j = {
         2 };
    	int k{
         3 };
    	return 0;
    }

--------------------

### ♥️ 2.2 std::initializer\_list ###

[std::initializer\_list介绍文档][std_initializer_list]

*  std::initializer\_list是什么类型

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

![在这里插入图片描述][67be34219bf345e789ebf843ab196f2a.png]

*  模拟实现的vector支持\{\}初始化和赋值

template<class T>
    class vector 
    {
        
    public:
    	typedef T* iterator;
    	vector(initializer_list<T> l)
    	{
        
    		_start = new T[l.size()];
    		_finish = _start + l.size();
    		_endofstorage = _start + l.size();
    		iterator vit = _start;
    		typename initializer_list<T>::iterator lit = l.begin();
    		while (lit != l.end())
    		{
        
    			*vit++ = *lit++;
    		}
    		//for (auto e : l)
    		//   *vit++ = e;
    	}
    	vector<T>& operator=(initializer_list<T> l) {
        
    		vector<T> tmp(l);
    		std::swap(_start, tmp._start);
    		std::swap(_finish, tmp._finish);
    		std::swap(_endofstorage, tmp._endofstorage);
    		return *this;
    	}
    private:
    	iterator _start;
    	iterator _finish;
    	iterator _endofstorage;
    };

*  std::initializer\_list使用场景

**std::initializer\_list一般是作为构造函数的参数，C++11对STL中的不少容器（像map、vector、list）就增加std::initializer\_list作为参数的构造函数，这样初始化容器对象就更方便了。也可以作为operator=的参数，这样就可以用大括号赋值**

class A
    {
        
    public:
    	A(int a, double d, int b)
    		:_a(a)
    		, _d(d)
    		, _b(b)
    	{
        }
    private:
    	int _a;
    	double _d;
    	int _b;
    };
    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()
    {
        
    	//内置类型的列表初始化
    	vector<int> v1 = {
         1, 2, 3, 4, 5 };
    	vector<int> v2{
         1, 2, 3, 4, 5 };
    	//vector (initializer_list<value_type> il,const allocator_type& alloc = allocator_type());
    
    
    	auto lt1 = {
        1, 2, 3, 4};
    	initializer_list<int> lt2 = {
         1, 2, 3, 4 };
    	//auto=initializer_list<int>
    
    
    	map<string, int> dict1 = {
         pair<string, int>("sort", 1), pair<string, int>("insert", 2) };
    	map<string, int> dict2 = {
         {
         "sort", 1 }, {
         "insert", 2 } };
    	//首先{ "sort", 1 }, { "insert", 2 }创建成initializer_list<map<string,int>>类型的对象
    	//最后map (initializer_list<value_type> il,const key_compare& comp = key_compare(),const allocator_type& alloc = allocator_type());
    	//这个构造函数初始化dict2
    
    
    	//自定义类型的列表初始化
    	Date d1(2022, 3, 13);
    	Date d2 = {
         2022, 3, 15 };
    	Date d3{
         2022, 3, 15 };
    	Date{
         2022, 3, 15 };
    
    
    	
    	A aa1 = {
         1, 1.11, 1};
    	list<A> lt = {
         {
         1, 1.11, 1}, {
         2, 2.22, 1} };
    	//首先{ { 1, 1.11, 1}, { 2, 2.22, 1} }创建成initializer_list<list<A>>类型的对象（首先是A类得有相应的构造函数才行）
    	//最后list的构造函数初始化it
    	return 0;
    }

--------------------

## ♠️ 3. 声明 ##

c++11提供了多种简化声明的方式，尤其是在使用模板时。

### ♥️ 3.1 auto ###

在C++98中auto是一个存储类型的说明符，表明变量是局部自动存储类型，但是局部域中定义局部的变量默认就是自动存储类型，所以auto就没什么价值了。**C++11中废弃auto原来的用法，将其用于实现自动类型腿断。这样要求必须进行显示初始化，让编译器将定义对象的类型设置为初始化值的类型。**

int main()
    {
        
    	int i = 10;
    	auto p = &i;
    	
    	auto pf = strcpy;
    	//输出p、pf的类型
    	cout << typeid(p).name() << endl;
    	cout << typeid(pf).name() << endl;
    	
    	map<string, string> dict = {
         {
        "sort", "排序"}, {
        "insert", "插入"} };
    	//map<string, string>::iterator it = dict.begin();
    	
    	auto it = dict.begin();
    	
    	return 0;
    }

--------------------

### ♥️ 3.2 decltype ###

**关键字decltype将变量的类型声明为表达式指定的类型**

// decltype的一些使用使用场景
    template<class T1, class T2>
    void F(T1 t1, T2 t2)
    {
        
    	decltype(t1 * t2) ret = t1 * t2;
    	vector<decltype(t1* t2)> v;
    	v.push_back(ret);
    	cout << typeid(ret).name() << endl;
    }
    
    int main()
    {
        
    	int i = 10;
    	auto p = &i;
    	auto pf = strcpy;
    	decltype(pf) pf1;    //char * (__cdecl*)(char *,char const *)
    	vector<decltype(pf)> v;
    
    	cout << typeid(p).name() << endl;
    	cout << typeid(pf).name() << endl;
    
    	return 0;
    }

**注意：decltype与auto的差别：auto必须要求显式初始化，而decltype没要求**

--------------------

### ♥️ 3.3 nullptr ###

由于C++中NULL被定义成字面量0，这样就可能回带来一些问题，因为0既能指针常量，又能表示整形常量。所以出于清晰和安全的角度考虑，**C++11中新增了nullptr，用于表示空指针。**

#ifndef NULL
    #ifdef __cplusplus
    #define NULL   0
    #else
    #define NULL   ((void *)0)
    #endif
    #endif

--------------------

## ♠️ 4. STL中一些变化 ##

**新容器**

用橘色圈起来是C++11中的一些几个新容器，但是实际最有用的是unordered\_map和  
unordered\_set。其他的大家了解一下即可。

![在这里插入图片描述][077e3e9e611c41df8e7045d42d95168a.png]

**容器中的一些新方法**

如果我们再细细去看会发现基本每个容器中都增加了一些C++11的方法，但是其实很多都是用得比较少的。  
比如提供了cbegin和cend方法返回const迭代器等等，但是实际意义不大，因为begin和end也是可以返回const迭代器的，这些都是属于锦上添花的操作。

--------------------

## ♠️ 5. final 和 override ##

**final**

*  final修饰类的时候，表示该类不能被继承

class A final //表示该类是最后一个类
    {
        
    private:
    	int _year;
    };
    class B : public A //无法继承
    {
        
    
    };

*  final修饰虚函数时，这个虚函数不能被重写

class A 
    {
        
    public:
    	virtual void fun() final//修饰虚函数
    	{
        
    		cout << "this is A" << endl;
    	}
    private:
    	int _year;
    };
    class B : public A
    {
        
    public:
    	virtual void fun()//父类虚函数用final修饰，表示最后一个虚函数，无法重写
    	{
        
    		cout << "this is B" << endl;
    	}
    };

--------------------

**override**

*  检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错

class A 
    {
        
    public:
    	virtual void fun()
    	{
        
    		cout << "this is A" << endl;
    	}
    private:
    	int _year;
    };
    class B : public A
    {
        
    public:
    	virtual void fun() override
    	{
        
    		cout << "this is B" << endl;
    	}
    };

--------------------

## ♠️ 6. 右值引用和移动语义 ##

### ♥️ 6.1 左值引用和右值引用 ###

传统的C++语法中就有引用的语法，而C++11中新增了的右值引用语法特性，**无论左值引用还是右值引用，都是给对象取别名。**

*  左值引用

左值是一个表示数据的表达式(如变量名或解引用的指针)，我们**可以获取它的地址+可以对它赋值，左值可以出现赋值符号的左边，右值不能出现在赋值符号左边**。定义时const修饰符后的左值，不能给他赋值，但是可以取它的地址。左值引用就是给左值的引用，给左值取别名。

int main()
    {
        
    	// 以下的p、b、c、*p都是左值
    	int* p = new int(0);
    	int b = 1;
    	const int c = 2;
    
    
    	//	可以取地址
    	cout << &p << endl;
    	cout << &b << endl;
    	cout << &c << endl;
    	cout << &(*p) << endl;
    	
    	b = c;
    	
    	// 以下几个是对上面左值的左值引用
    	int*& rp = p;
    	int& rb = b;
    	const int& rc = c;
    	int& pvalue = *p;
    	return 0;
    }

*  右值引用

右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值(这个不能是左值引用返回)等等，**右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址**。右值引用就是对右值的引用，给右值取别名。

int main()
    {
        
    	double x = 1.1, y = 2.2;
    	// 以下几个都是常见的右值
    	10; 
    	x + y;
    	fmin(x, y);
    	// 以下几个都是对右值的右值引用
    	int&& rr1 = 10;
    	double&& rr2 = x + y;
    	double&& rr3 = fmin(x, y);
    	
    	//	// 不能取地址
    	//	cout << &10 << endl;
    	//	cout << &(x+y) << endl;
    	//	cout << &fmin(x, y) << endl;
    	
    	// 这里编译会报错：error C2106: “=”: 左操作数必须为左值
    	//10 = 1; 
    	//x + y = 1;
    	//fmin(x, y) = 1;
    	return 0;
    }

需要注意的是右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可以取到该位置的地址，也就是说例如：不能取字面量10的地址，但是rr1引用后，可以对rr1取地址，也可以修改rr1。如果不想rr1被修改，可以用const int&& rr1 去引用

int main()
    {
        
    	double x = 1.1, y = 2.2;
    	int&& rr1 = 10;
    	const double&& rr2 = x + y;
    	rr1 = 20;
    	int& rr = rr1;
    	//rr2 = 5.5;  // 报错
    	return 0;
    }

**注意：左值引用可以连续左值引用，而右值引用是不可以连续右值引用的（右值引用后该变量为左值，不能使用右值引用了）**

--------------------

### ♥️ 6.2 左值引用和右值引用比较 ###

**左值引用总结：**

1.  左值引用只能引用左值，不能引用右值。
2.  但是const左值引用既可引用左值，也可引用右值

int main()
    {
        
    	// 左值引用只能引用左值，不能引用右值。
    	int a = 10;
    	int& ra1 = a;// ra为a的别名
    	//int& ra2 = 10;// 编译失败，因为10是右值
    	// const左值引用既可引用左值，也可引用右值。
    	const int& ra3 = 10;
    	const int& ra4 = a;
    	return 0;
    }

**右值引用总结：**

1.  右值引用只能右值，不能引用左值。
2.  但是右值引用可以move以后的左值。

int main()
    {
        
    	// 右值引用只能右值，不能引用左值
    	int&& r1 = 10;
    
    	// error C2440: “初始化”: 无法从“int”转换为“int &&”
    	// message : 无法将左值绑定到右值引用
    	int a = 10;
    	//int&& r2 = a;  //报错 右值引用只能右值，不能引用左值
    	// 右值引用可以引用move以后的左值
    	int&& r3 = move(a);
    	return 0;
    }

--------------------

### ♥️ 6.3 右值引用使用场景和意义 ###

**右值引用可以补齐左值引用的短板**

namespace lc
    {
        
    	class string
    	{
        
    	public:
    		typedef char* iterator;
    		iterator begin()
    		{
        
    			return _str;
    		}
    
    		iterator end()
    		{
        
    			return _str + _size;
    		}
    
    		string(const char* str = "")
    			:_size(strlen(str))
    			, _capacity(_size)
    		{
        
    			//cout << "string(char* str)" << endl;
    
    			_str = new char[_capacity + 1];
    			strcpy(_str, str);
    		}
    
    		// s1.swap(s2)
    		void swap(string& s)
    		{
        
    			::swap(_str, s._str);
    			::swap(_size, s._size);
    			::swap(_capacity, s._capacity);
    		}
    
    		// 拷贝构造
    		string(const string& s)
    			:_str(nullptr)
    		{
        
    			cout << "string(const string& s) -- 深拷贝" << endl;
    
    			string tmp(s._str);
    			swap(tmp);
    		}
    
    		// 移动构造
    		string(string&& s)
    			:_str(nullptr)
    			, _size(0)
    			, _capacity(0)
    		{
        
    			cout << "string(string&& s) -- 移动拷贝" << endl;
    
    			//this->swap(s);
    			swap(s);
    		}
    
    		// 赋值重载
    		string& operator=(const string& s)
    		{
        
    			cout << "string& operator=(string s) -- 深拷贝" << endl;
    			string tmp(s);
    			swap(tmp);
    
    			return *this;
    		}
    
    		~string()
    		{
        
    			delete[] _str;
    			_str = nullptr;
    		}
    
    		char& operator[](size_t pos)
    		{
        
    			assert(pos < _size);
    			return _str[pos];
    		}
    
    		void reserve(size_t n)
    		{
        
    			if (n > _capacity)
    			{
        
    				char* tmp = new char[n + 1];
    				strcpy(tmp, _str);
    				delete[] _str;
    				_str = tmp;
    
    				_capacity = n;
    			}
    		}
    
    		void push_back(char ch)
    		{
        
    			if (_size >= _capacity)
    			{
        
    				size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
    				reserve(newcapacity);
    			}
    
    			_str[_size] = ch;
    			++_size;
    			_str[_size] = '\0';
    		}
    
    		//string operator+=(char ch)
    		string& operator+=(char ch)
    		{
        
    			push_back(ch);
    			return *this;
    		}
    
    		const char* c_str() const
    		{
        
    			return _str;
    		}
    	private:
    		char* _str;
    		size_t _size;
    		size_t _capacity; // 不包含最后做标识的\0
    	};
    }

--------------------

### ♥️ 6.4 左值引用使用场景 ###

void func1(bit::string s)
    {
        }
    
    void func2(const bit::string& s)
    {
        }
    
    int main()
    {
        
    	bit::string s1("hello world");
    	// func1和func2的调用我们可以看到左值引用做参数减少了拷贝，提高效率的使用场景和价值
    	func1(s1);
    	func2(s1);
    	
    	// string operator+=(char ch) 传值返回存在深拷贝
    	// string& operator+=(char ch) 传左值引用没有拷贝提高了效率
    	s1 += '!';
    	
    	return 0;
    }

### ♥️ 6.4 左值引用短板 ###

但是当函数返回对象是一个局部变量，出了函数作用域就不存在了，就不能使用左值引用返回，只能传值返回。例如：bit::string to\_string(int value)函数中可以看到，这里只能使用传值返回，传值返回会导致至少1次拷贝构造(如果是一些旧一点的编译器可能是两次拷贝构造)。

![在这里插入图片描述][4b6d08eaa245441aba542012d5371436.png]  
![在这里插入图片描述][e578098cedb64706a13e02de290047a4.png]  
![在这里插入图片描述][db0f46c68d4942e8838866cf818a9596.png]

--------------------

### ♥️ 6.5 右值引用和移动语义解决上述问题 ###

移动构造本质是将参数右值的资源窃取过来，占位已有，那么就不用做深拷贝了，所以它叫做移动构造，就是窃取别人（将亡值）的资源来构造自己。

![在这里插入图片描述][d49dbf3df68a4fb3981552851f24cce1.png]  
**注意：出了作用域，如果返回对象不在了，不能使用引用返回(左值引用和右值引用都不可以)**

namespace byih
    {
        
    	class string
    	{
        
    	public:
    		typedef char* iterator;
    		iterator begin()
    		{
        
    			return _str;
    		}
    
    		iterator end()
    		{
        
    			return _str + _size;
    		}
    
    		string(const char* str = "")
    			:_size(strlen(str))
    			, _capacity(_size)
    		{
        
    			//cout << "string(char* str)" << endl;
    
    			_str = new char[_capacity + 1];
    			strcpy(_str, str);
    		}
    
    		// s1.swap(s2)
    		void swap(string& s)
    		{
        
    			::swap(_str, s._str);
    			::swap(_size, s._size);
    			::swap(_capacity, s._capacity);
    		}
    
    		// 拷贝构造
    		string(const string& s)
    			:_str(nullptr)
    			, _size(0)
    			, _capacity(0)
    		{
        
    			cout << "string(const string& s) -- 深拷贝" << endl;
    
    			string tmp(s._str);
    			swap(tmp);
    		}
    
    		// 移动构造
    		string(string&& s)
    			:_str(nullptr)
    			, _size(0)
    			, _capacity(0)
    		{
        
    			cout << "string(string&& s) -- 移动拷贝" << endl;
    			//this->swap(s);
    			swap(s);
    		}
    
    		// 拷贝赋值
    		string& operator=(const string& s)
    		{
        
    			cout << "string& operator=(const string& s) -- 深拷贝" << endl;
    			string tmp(s);
    			swap(tmp);
    
    			return *this;
    		}
    
    		// 移动赋值
    		string& operator=(string&& s)
    		{
        
    			cout << "string& operator=(string&& s) -- 移动赋值" << endl;
    			swap(s);
    
    			return *this;
    		}
    
    		~string()
    		{
        
    			delete[] _str;
    			_str = nullptr;
    		}
    
    		char& operator[](size_t pos)
    		{
        
    			assert(pos < _size);
    			return _str[pos];
    		}
    
    		void reserve(size_t n)
    		{
        
    			if (n > _capacity)
    			{
        
    				char* tmp = new char[n + 1];
    				strcpy(tmp, _str);
    				delete[] _str;
    				_str = tmp;
    
    				_capacity = n;
    			}
    		}
    
    		void push_back(char ch)
    		{
        
    			if (_size >= _capacity)
    			{
        
    				size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
    				reserve(newcapacity);
    			}
    
    			_str[_size] = ch;
    			++_size;
    			_str[_size] = '\0';
    		}
    
    		//string operator+=(char ch)
    		string& operator+=(char ch)
    		{
        
    			push_back(ch);
    			return *this;
    		}
    
    		const char* c_str() const
    		{
        
    			return _str;
    		}
    
    		void clear()
    		{
        
    			_str[0] = '\0';
    			_size = 0;
    		}
    	private:
    		char* _str;
    		size_t _size;
    		size_t _capacity; // 不包含最后做标识的\0
    	};
    
    
    
    	string to_string(int val)
    	{
        
    		string str;
    		while (val)
    		{
        
    			int i = val % 10;
    			str += ('0' + i);
    			val /= 10;
    		}
    		reverse(str.begin(), str.end());
    		return str;
    	}
    }

![在这里插入图片描述][9fff499cee7347abb903c98885fa35f0.png]

![在这里插入图片描述][2103a1fb345d450db5ced8fb44ee2d7a.png]

**右值是将亡值而将亡值不一定是右值**

**注意：**

按照语法，右值引用只能引用右值，但右值引用也能引用左值。因为：有些场景下，可能 真的需要用右值去引用左值实现移动语义。当需要用右值引用引用一个左值时，可以通过move 函数将左值转化为右值。C++11中，std::move()函数位于 头文件中，该函数名字具有迷惑性， 它并不搬移任何东西，唯一的功能就是将一个左值强制转化为右值引用，然后实现移动语义。  
使用move函数时，要注意该对象的资源（所开空间），该对象的资源会根据移动赋值、移动拷贝来决定，建议使用完move函数之后不要再使用该对象了

--------------------

### ♥️ 6.6 STL容器插入接口函数也增加了右值引用版本 ###

void push_back (value_type&& val);
    int main()
    {
        
    	list<bit::string> lt;
    	bit::string s1("1111");
    	// 这里调用的是拷贝构造
    	lt.push_back(s1);
    	// 下面调用都是移动构造
    	lt.push_back("2222");
    	lt.push_back(std::move(s1));
    	return 0;
    }
    
    运行结果：
    // string(const string& s) -- 深拷贝
    // string(string&& s) -- 移动语义
    // string(string&& s) -- 移动语义

![在这里插入图片描述][dc2fb397341542dd8ca5f0d06776b46c.png]

--------------------

[Link 1]: https://blog.csdn.net/m0_60338933?type=blog
[eabca17da9704379a5f15832a495b4cc.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/d708d1a6fce54820af74cb821892357a.jpeg
[std_initializer_list]: https://cplusplus.com/reference/initializer_list/initializer_list/
[67be34219bf345e789ebf843ab196f2a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/27cf8970923043a8b9b05de0298098c8.png
[077e3e9e611c41df8e7045d42d95168a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/e875b2c259464d8ea6c0c47b1b46d3d7.png
[4b6d08eaa245441aba542012d5371436.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/08bd584706664638ad9c524986ee43a4.png
[e578098cedb64706a13e02de290047a4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/7ba3b2b959004daab609203ccdb4dbcc.png
[db0f46c68d4942e8838866cf818a9596.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/029adc561d314c78b93049df8993fe06.png
[d49dbf3df68a4fb3981552851f24cce1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/1fd35d97d62e4d0e82346eb224851331.png
[9fff499cee7347abb903c98885fa35f0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/a16a30c662914e948568b4ca23e20fe3.png
[2103a1fb345d450db5ced8fb44ee2d7a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/80ddde1064ec43259c7996da10c067b2.png
[dc2fb397341542dd8ca5f0d06776b46c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/a83bfcef91f3490f8486e4ad82f67e32.png