【C++详解】C++11(一) 列表初始化、右值引⽤和移动语义

一、列表初始化

C++98传统的{}

C++98中⼀般数组和结构体可以⽤{}进⾏初始化。

struct Point
{
int _x;
int _y;
};
int main()
{
int array1[] = { 1, 2, 3, 4, 5 };
int array2[5] = { 0 };
Point p = { 1, 2 };
return 0;
}

C++11中的{}

• C++11以后想统⼀初始化⽅式，试图实现⼀切对象皆可⽤{}初始化，{}初始化也叫做列表初始化。
• 内置类型⽀持，⾃定义类型也⽀持，⾃定义类型本质是类型转换，中间会产⽣临时对象，最后优化了以后变成直接构造。
• {}初始化的过程中，可以省略掉=。
• C++11列表初始化的本意是想实现⼀个⼤统⼀的初始化⽅式，其次他在有些场景下带来的不少便利，如容器push/inset多参数构造的对象时，{}初始化会很⽅便。

struct Point
{
	int _x;
	int _y;
};
class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{
		cout << "Date(int year, int month, int day)" << endl;
	}
	Date(const Date& d)
		:_year(d._year)
		, _month(d._month)
		, _day(d._day)
	{
		cout << "Date(const Date& d)" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

// ⼀切皆可⽤列表初始化，且可以不加=
int main()
{
	// C++98⽀持的
	int a1[] = { 1, 2, 3, 4, 5 };
	int a2[5] = { 0 };
	Point p = { 1, 2 };

	// C++11⽀持的
	// 内置类型⽀持
	int x1 = { 2 };

	// ⾃定义类型⽀持
	// 这⾥本质是⽤{ 2025, 1, 1}构造⼀个Date临时对象
	// 临时对象再去拷⻉构造d1，编译器优化后合⼆为⼀变成{ 2025, 1, 1}直接构造初始化d1
	// 运⾏⼀下，我们可以验证上⾯的理论，发现是没调⽤拷⻉构造的
	Date d1 = { 2025, 1, 1 };
	// 这⾥是引用无法优化，必须引用对象，d2引⽤的是{ 2024, 7, 25 }构造的临时对象,所以必须加const
	const Date& d2 = { 2024, 7, 25 };
	// 需要注意的是C++98⽀持单参数时类型转换(因为Date构造有缺省参数)，也可以不⽤{}
	Date d3 = { 2025 };
	Date d4 = 2025;

	// 可以省略掉=
	Point p1{ 1, 2 };
	int x2{ 2 };
	Date d6{ 2024, 7, 25 };
	const Date& d7{ 2024, 7, 25 };
	// 不⽀持，只有{}初始化，才能省略=
	// Date d8 2025;

	vector<Date> v;
	v.push_back(d1); //有名对象
	v.push_back(Date(2025, 1, 1)); //匿名对象
	// ⽐起有名对象和匿名对象传参，这⾥{}更有性价⽐
	v.push_back({ 2025, 1, 1 });
	return 0;
}

C++11中的std::initializer_list

1、上⾯的初始化已经很⽅便，但是对象容器初始化还是不太⽅便，⽐如⼀个vector对象，只支持n个val初始化，如果我想⽤N个值不同的值去构造初始化，是不支持的。
2、所以C++11库中提出了⼀个std::initializer_list的类:

auto il = { 10, 20, 30 }; // the type of il is an initializer_list 
initializer_list<int> il1 = { 10, 20, 30, 40, 50 };

这个类的本质是底层开⼀个数组，将数据拷⻉过来，std::initializer_list内部有两个指针分别指向数组的开始和结束,所以initializer_list对象大小在32位下是8个字节。

cout << sizeof(il1) << endl; //8

3、这是他的⽂档：initializer_list，std::initializer_list⽀持迭代器遍历。
4、容器⽀持⼀个std::initializer_list的构造函数，也就⽀持任意多个值构成的 {x1,x2,x3…}
进⾏初始化。STL中的容器⽀持任意多个值构成的 {x1,x2,x3…} 进⾏初始化，就是通过
std::initializer_list的构造函数⽀持的。

// STL中的容器都增加了⼀个initializer_list的构造
vector(initializer_list<value_type> il, const allocator_type& alloc =
	allocator_type());
list(initializer_list<value_type> il, const allocator_type& alloc =
	allocator_type());
map(initializer_list<value_type> il, const key_compare& comp =
	key_compare(), const allocator_type& alloc = allocator_type());
// ...

//底层实现
template<class T>
class vector {
public:
	typedef T* iterator;
	vector(initializer_list<T> l)
	{
		for (auto e : l)
			push_back(e)
	}
private:
	iterator _start = nullptr;
	iterator _finish = nullptr;
	iterator _endofstorage = nullptr;
};

// 另外，容器的赋值也⽀持initializer_list的版本
vector& operator= (initializer_list<value_type> il);
map& operator= (initializer_list<value_type> il);

用例：

#include<iostream>
#include<vector>
#include<string>
#include<map>
using namespace std;
int main()
{
	std::initializer_list<int> mylist;
	mylist = { 10, 20, 30 };
	cout << sizeof(mylist) << endl;
	// 这⾥begin和end返回的值initializer_list对象中存的两个指针
	// 这两个指针的值跟i的地址跟接近，说明数组存在栈上
	int i = 0;
	cout << mylist.begin() << endl;
	cout << mylist.end() << endl;
	cout << &i << endl;
	
	// {}列表中可以有任意多个值
	// 这两个写法语义上还是有差别的，第⼀个v1是直接构造，
	// 第⼆个v2是构造临时对象+临时对象拷⻉v2+优化为直接构造
	vector<int> v1({ 1,2,3,4,5 });
	vector<int> v2 = { 1,2,3,4,5 };
	const vector<int>& v3 = { 1,2,3,4,5 };
	
	// 这⾥是pair对象的{}初始化和map的initializer_list构造结合到⼀起⽤了
	map<string, string> dict = { {"sort", "排序"}, {"string", "字符串"} };
	
	// initializer_list版本的赋值⽀持
	v1 = { 10,20,30,40,50 };
	return 0;
}

最后需要注意区分以下两种列表初始化：

	Date d1 = { 2025, 1, 1 };
	vector<int> v2 = { 1,2,3,4,5 };

它们看起来一样，但是底层原理是完全不同的。
第一个是有Date类的三个参数的构造函数支持的，最多只能传三个参数，它是由三个参数隐式类型转化构造一个Date临时对象再拷贝构造，编译器优化为直接构造。
第二个可以传递任意多个参数，这里是由5个参数隐式类型转换为initializer_list，然后直接调用vector的initializer_list构造初始化v2。
总结：也就是说{}可以匹配两个东西，一个是匹配某个类的构造初始化，一个是匹配initializer_list参数。

二、右值引⽤和移动语义

C++98的C++语法中就有引⽤的语法，⽽C++11中新增了的右值引⽤语法特性，C++11之后我们之前学习的引⽤就叫做左值引⽤。⽆论左值引⽤还是右值引⽤，都是给对象取别名。

左值和右值

• 左值是⼀个表⽰数据的表达式(如变量名或解引⽤的指针)，⼀般是有持久状态，存储在内存中，我们可以获取它的地址，左值可以出现赋值符号的左边，也可以出现在赋值符号右边。定义时const修饰符后的左值，不能修改，但是可以取它的地址。
• 右值也是⼀个表⽰数据的表达式，要么是字⾯值常量、要么是表达式求值过程中创建的临时对象、传值返回的临时对象，匿名对象等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边(引用除外)，右值不能取地址，并且不能被修改。
• 值得⼀提的是，左值的英⽂简写为lvalue，右值的英⽂简写为rvalue。传统认为它们分别是leftvalue、right value 的缩写。现代C++中，lvalue 被解释为loactor value的缩写，可意为存储在内存中、有明确存储地址可以取地址的对象，⽽rvalue 被解释为 read value，指的是那些可以提供数据值，但是不可以寻址，例如：临时变量，字⾯量常量，存储于寄存器中的变量等，也就是说左值和右值的核⼼区别就是能否取地址。

#include<iostream>
using namespace std;
int main()
{
	// 左值：可以取地址
	// 以下的p、b、c、*p、s、s[0]就是常⻅的左值
	int* p = new int(0);
	int b = 1;
	const int c = b;
	*p = 10;
	string s("111111");
	s[0] = 'x';
	cout << &c << endl;
	cout << (void*)&s[0] << endl;

	// 右值：不能取地址
	double x = 1.1, y = 2.2;
	// 以下⼏个10、x + y、fmin(x, y)、string("11111")都是常⻅的右值
	10;               //字面量常量
	x + y;            //表达式求值返回临时对象
	fmin(x, y);       //传值返回临时对象
	string("11111");  //匿名对象
	//cout << &10 << endl;
	//cout << &(x+y) << endl;
	//cout << &(fmin(x, y)) << endl;
	//cout << &string("11111") << endl;
	return 0;
}

注意上面cout << (void*)&s[0] << endl;这里需要强转为void*。因为cout是函数重载自动匹配类型，它会优先匹配到const char* 类型，cout会对const char* 类型进行特殊处理，会默认将其视为字符串的起始地址，尝试从该地址开始打印字符，直到遇到空终止符
‘\0’。这显然不是我们的目的，我们想输出的是指针本身的内存地址，而不是字符串内容。所以需要进行强转，当 cout 遇到 void*类型的指针时，会直接输出该指针所指向的内存地址值（以十六进制形式），这正是我们希望看到的结果。

左值引⽤和右值引⽤

• Type& r1 = x; Type&& rr1 = y; 第⼀个语句就是左值引⽤，左值引⽤就是给左值取别 名，第⼆个就是右值引⽤，同样的道理，右值引⽤就是给右值取别名。

• 左值引⽤不能直接引⽤右值，但是const左值引⽤可以引⽤右值

• 右值引⽤不能直接引⽤左值，但是右值引⽤可以引⽤move(左值)

• move是库⾥⾯的⼀个函数模板，本质内部是进⾏强制类型转换，当然他还涉及⼀些引⽤折叠的知识，这个我们后⾯会细讲。

• 需要注意的是变量表达式都是左值属性(“变量表达式” 指的是由变量名构成的表达式,简单理解，就是直接使用变量名作为表达式，比如 x、r 这样的写法，实践中函数形参也叫变量表达式)，也就意味着⼀个右值被右值引⽤绑定后成了右值引⽤变量，该变量表达式的属性是左值。比如后面我们介绍的移动构造和移动赋值的参数就是右值引用变量，这里的右值引用变量都是需要被改变的，所以这个例子的右值引⽤变量必须具有左值属性。再结合下面代码理解，只有当右值引⽤变量具有左值属性时可以调用swap函数。
  总结：只有s的属性是左值，才能转移s引用的右值对象的资源。

• 语法层⾯看，左值引⽤和右值引⽤都是取别名，不开空间。从汇编底层的⻆度看下⾯代码中r1和rr1汇编层实现，底层都是⽤指针实现的，没什么区别。所以这里可以证明底层汇编等实现和上层语法表达的意义有时是背离的。

// 左值引⽤给左值取别名
int& r1 = b;
int*& r2 = p;
int& r3 = *p;
string& r4 = s;
char& r5 = s[0];

// 右值引⽤给右值取别名
int&& rr1 = 10;
double&& rr2 = x + y;
double&& rr3 = fmin(x, y);
string&& rr4 = string("11111");

// 左值引⽤不能直接引⽤右值，但是const左值引⽤可以引⽤右值
const int& rx1 = 10;
const double& rx2 = x + y;
const double& rx3 = fmin(x, y);
const string& rx4 = string("11111");

// 右值引⽤不能直接引⽤左值，但是右值引⽤可以引⽤move(左值)
int&& rrx1 = move(b);
int*&& rrx2 = move(p);
int&& rrx3 = move(*p);
string&& rrx4 = move(s);
string&& rrx5 = (string&&)s;

上面的move函数可以暂时理解成强转。

引⽤延⻓⽣命周期

右值引⽤可⽤于为临时对象延⻓⽣命周期，如匿名对象和表达式求值返回值的生命周期都只在当前这一行，const的左值引⽤也能延⻓临时对象⽣存期，将临时对象的生命周期延长到和引用对象一样，但这些对象⽆法被修改。
下面代码中右值引用对象r3能被修改小编这里暂时不细讲，需要结合后续知识理解。

int main()
{
	std::string s1 = "Test";
	// std::string&& r1 = s1; // 错误：不能绑定到左值

	const std::string& r2 = s1 + s1; // OK：到 const 的左值引⽤延⻓⽣存期
	// r2 += "Test"; // 错误：不能通过到 const 的引⽤修改

	std::string&& r3 = s1 + s1; // OK：右值引⽤延⻓⽣存期
	r3 += "Test"; // OK：能通过到⾮ const 的引⽤修改
	std::cout << r3 << '\n';
	return 0;
}

左值和右值的参数匹配

• C++98中，我们实现⼀个const左值引⽤作为参数的函数，那么实参传递左值和右值都可以匹配。
• C++11以后，分别重载左值引⽤、const左值引⽤、右值引⽤作为形参的f函数，那么实参是左值会匹配f(左值引⽤)，实参是const左值会匹配f(const
  左值引⽤)，实参是右值会匹配f(右值引⽤)。
• 右值引⽤变量在⽤于表达式时属性是左值，这个设计这⾥会感觉跟怪，下⼀⼩节我们讲右值引⽤的使⽤场景时，就能体会这样设计的价值了。

void f(int& x)
{
	std::cout << "左值引⽤重载 f(" << x << ")\n";
}

void f(const int& x)
{
	std::cout << "到 const 的左值引⽤重载 f(" << x << ")\n";
}

void f(int&& x)
{
	std::cout << "右值引⽤重载 f(" << x << ")\n";
}

int main()
{
	int i = 1;
	const int ci = 2;
	f(i); // 调⽤ f(int&)
	f(ci); // 调⽤ f(const int&)
	f(3); // 调⽤ f(int&&)，如果没有 f(int&&) 重载则会调⽤ f(const int&)
	f(std::move(i)); // 调⽤ f(int&&)
	// 右值引⽤变量在⽤于表达式时是左值
	int&& x = 1;
	f(x); // 调⽤ f(int& x)
	f(std::move(x)); // 调⽤ f(int&& x)
	return 0;
}

右值引⽤和移动语义的使⽤场景

左值引⽤主要使⽤场景回顾

左值引⽤主要使⽤场景是在函数中左值引⽤传参和左值引⽤传返回值时减少拷⻉，同时还可以修改形参影响实参。左值引⽤已经解决⼤多数场景的拷⻉效率问题，但是有些场景不能使⽤传左值引⽤返回，如addStrings和generate函数，返回值对象出了作用域就销毁了。那么C++11以后这⾥可以使⽤右值引⽤做返回值解决吗？显然是不可能的，因为这⾥返回对象本质是⼀个局部对象，函数结束这个对象就析构销毁了，右值引⽤返回也⽆法概念对象已经析构销毁的事实。这里就需要借助下面介绍的两个新概念，移动构造和移动赋值。

移动构造和移动赋值

• 移动构造函数是⼀种构造函数，类似拷⻉构造函数，拷⻉构造函数和移动构造函数都要求第⼀个参数是该类类型的引⽤(强制要求，避免无限递归)，但是移动构造函数要求这个参数是右值引⽤，如果还有其他参数，额外的参数必须有缺省值。
• 移动赋值是一种赋值运算符重载，他跟拷⻉赋值构成函数重载，类似拷⻉赋值函数，移动赋值函数和拷⻉赋值函数都要求第⼀个参数是该类类型的引⽤(非强制要求，传引用减少拷贝)，但是不同的是要求这个参数是右值引⽤。
• 有了移动构造和移动赋值后左值对象(持久存在)匹配拷⻉构造和拷⻉赋值，右值对象(即将消亡”的对象)匹配移动构造和移动赋值，移动构造/移动赋值和拷⻉构造/拷⻉赋值构成重载的其中一个重要目的是把自定义类型对象参数是左值还是右值区分出来(移动构造和移动赋值这里我们只讨论自定义类型，自定义类型的右值指那些快到生命周期的对象如临时对象和匿名对象，通常不包含字面量)。
• 上面介绍的移动构造和移动赋值虽然函数形参是右值引用，但是不会触发右值引用延长临时对象生命周期，因为只有纯右值直接绑定到右值引用变量时会延长，例如T&&
  ref = T();，这个右值引用是 “最终持有者”，
  需要这个对象一直存在，所以编译器延长它的寿命，让它跟着引用走。当右值引用是函数形参时，它是“资源传递者”，它的唯一作用是把右值里的资源转给函数内的其他对象（比如 s3），传递完成后，原右值（匿名对象）就成了“空壳”，没有保留的必要，自然不会延长寿命。

 wusaqi::string s3 = wusaqi::string("yyyyy");

• 移动构造函数只负责资源的所有权转移，无法改变对象本身的生命周期属性，比如上面代码示例，s3 获得了匿名对象的堆内存、长度等资源，匿名对象的 _str 变成了交换前s3
  内部的nullptr，s3的生命周期仍是在当前栈帧结束后销毁，匿名对象的生命周期也只在这一行，这也正是移动语义的设计初衷：高效转移资源，同时保证对象生命周期的语法规则不受破坏。
• 对于像string/vector这样的深拷⻉的类或者包含深拷⻉的成员变量的类，移动构造和移动赋值才有意义。因为移动构造和移动赋值的第⼀个参数都是右值引⽤的类型，他的本质是要“窃取”引⽤的右值对象的资源，因为右值对象生命周期只在当前这一行，所以可以随意修改源对象。⽽拷⻉构造和拷⻉赋值是去拷⻉资源，不改变原对象的状态。可以结合下面的拷贝构造的现代写法和移动构造理解。

下面示例代码小编就不展示string的所有实现细节了，只展示一部分重要的。

namespace wusaqi
{
	class string
	{
	public:
		string(const char* str = "")
			:_size(strlen(str))
			, _capacity(_size) 
		{
			cout << "string(char* str)-构造" << endl;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}
		
		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;
			reserve(s._capacity);
			for (auto ch : s)
			{
				push_back(ch);
			}
		} 
		
        //拷贝构造的现代写法
        //string(const string& s)
        //{
		//    string tmp(s._str); //交给别人拷贝资源，不用自己手动拷贝
		//    swap(tmp);
	    //}
	    
		// 移动构造
		string(string&& s)
		{
			cout << "string(string&& s) -- 移动构造" << endl;
			swap(s);
		}
        //拷贝赋值
		string& operator=(const string& s)
		{
			cout << "string& operator=(const string& s) -- 拷贝赋值" << endl;
			if (this != &s)
			{
				_str[0] = '\0';
				_size = 0;
				reserve(s._capacity);
				for (auto ch : s)
				{
					push_back(ch);
				}
			}
			return *this;
		}
		// 移动赋值
		string& operator=(string&& s)
		{
			cout << "string& operator=(string&& s) -- 移动赋值" << endl;
			swap(s);
			return *this;
		}
		//析构
		~string()
		{
			cout << "~string() -- 析构" << endl;
			delete[] _str;
			_str = nullptr;
		}

		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';
		}

	private:
		char* _str = nullptr;
		size_t _size = 0;
		size_t _capacity = 0;
	};
}

int main()
{
	wusaqi::string s1("xxxxx");
	// 拷贝构造
	wusaqi::string s2 = s1;
	// 构造+移动构造，优化后直接构造
	wusaqi::string s3 = wusaqi::string("yyyyy");
	// 移动构造
	wusaqi::string s4 = move(s1);
	return 0;
}

右值引⽤和移动语义解决传值返回问题

右值对象构造

• 第一张图是只有拷⻉构造，没有移动构造的场景，展⽰了vs2019 debug环境下编译器对拷⻉的优化，左边为不优化的情况下，两次拷⻉构造，右边为编译器优化的场景下连续步骤中的拷⻉合⼆为⼀变为⼀次拷⻉构造。linux下可以将下⾯代码拷⻉到test.cpp⽂件，编译时⽤ g++ test.cpp -fno-elide-constructors 的⽅式关闭构造优化，运⾏结果可以看到图1左边没有优化的两次拷⻉。

• 第二张图是有拷⻉构造，也有移动构造的场景，也是在vs2019 debug环境下，左边为不优化的情况下，两次移动构造，右边为编译器优化的场景下连续步骤中的拷⻉合⼆为⼀变为⼀次移动构造。

• 第三张图是在vs2019的release和vs2022的debug和release环境下，这时的代码优化行为⾮常恐怖，这里拷贝构造和移动构造的优化一样，下面以移动构造为例，会直接将str对象的构造，str移动构造临时对象，临时对象移动构造ret对象，合三为⼀，变为直接构造。
  

右值对象赋值

• 下图是只有拷⻉构造和拷⻉赋值，没有移动构造和移动赋值的场景，左边展⽰了vs2019 debug和 g++ test.cpp -fno-elide-constructors 关闭优化环境
  下编译器的处理，⼀次拷⻉构造，⼀次拷⻉赋值。
• 下图右边是在vs2019的release和vs2022的debug和release下⾯代码会进⼀步优化，这里无法一步到位，因为是一个已经存在的对象给另一个已经存在的对象赋值。这里优化后str本质是临时对象的引⽤，底层⻆度⽤指针实现。从运⾏结果的⻆度，我们可以看到str的析构是在赋值以后，说明str就是临时对象的别名。
• 既有拷⻉构造和拷⻉赋值，也有移动构造和移动赋值的场景的右值对象赋值也和上面差不多，小编就不过多解释了。

总结：
传值返回的场景，没有移动构造移动赋值时，依赖编译器的优化，没有优化时拷贝构造接收和赋值接收拷贝代价都很高，优化全开时拷贝构造接收场景代价底，赋值接收场景有一定拷贝代价。
传值返回的场景，有移动构造移动赋值时，不依赖编译器的优化，无论是拷贝接收还是赋值接收，代价都很低，因为移动构造和移动赋值没有拷贝代价。

右值引⽤和移动语义在传参中的提效

• 查看STL⽂档我们发现C++11以后容器的push和insert系列的接⼝都增加了右值引⽤版本。
• 当实参是⼀个左值时，容器内部继续调⽤拷⻉构造进⾏拷⻉，将对象拷⻉到容器空间中的对象。
• 当实参是⼀个右值，容器内部则调⽤移动构造，把右值对象的资源转移到容器空间的对象上。
• 把我们之前模拟实现的bit::list拷⻉过来，⽀持右值引⽤参数版本的push_back和insert
• 其实这⾥还有⼀个emplace系列的接⼝，但是这个涉及可变参数模板，我们需要把可变参数模板讲解以后再讲解emplace系列的接⼝。

下面小编演示一个例子，通过改造list相关接口使得insert右值对象能调用移动构造。
首先需要从push_back开始，向下依次实现push_back、insert乃至list_node的构造初始化的右值引用参数的函数重载，实现重载时要注意两点，第一要把右值引用参数的const去掉，因为需要修改源对象，转移资源。第二是每次参数传递时需要手动把具有左值属性的参数改为右值属性(手动加move)才能往下匹配调用右值引用的函数重载版本，使得在最后调用string的移动构造时参数也具有右值属性，最后才能成功匹配到移动构造。

template<class T>
struct list_node
{
	T _data;
	list_node<T>* _next;
	list_node<T>* _prev;

	list_node(const T& x = T())
		:_data(x)
		, _next(nullptr)
		, _prev(nullptr)
	{
	}

	list_node(T&& x)
		:_data(move(x)) //move使x保持右值属性
		, _next(nullptr)
		, _prev(nullptr)
	{
	}
};

void push_back(const T& x)
{
	insert(end(), x);
}

void push_back(T&& x)
{
	insert(end(), move(x));  //move使x保持右值属性
}

iterator insert(iterator pos, const T& val)
{
	Node* cur = pos._node;
	Node* newnode = new Node(val);
	Node* prev = cur->_prev; 
	prev->_next = newnode;
	newnode->_next = cur;
	cur->_prev = newnode;
	newnode->_prev = prev;
	_size++;

	return newnode;
}

iterator insert(iterator pos, T&& val)
{
	Node* cur = pos._node;
	Node* newnode = new Node(move(val));  //move使val保持右值属性
	Node* prev = cur->_prev; 

	prev->_next = newnode;
	newnode->_next = cur;
	cur->_prev = newnode;
	newnode->_prev = prev;
	_size++;

	return newnode;
}

int main()
{
std::list<bit::string> lt;
bit::string s1("111111111111111111111");
lt.push_back(s1);
cout << "*************************" << endl;
lt.push_back(bit::string("22222222222222222222222222222"));
cout << "*************************" << endl;
lt.push_back("3333333333333333333333333333");
cout << "*************************" << endl;
lt.push_back(move(s1));
cout << "*************************" << endl;
return 0;
}

运⾏结果：
string(char* str)
string(const string& s) -- 拷⻉构造
*************************
string(char* str)
string(string&& s) -- 移动构造
~string() -- 析构
*************************
string(char* str)
string(string&& s) -- 移动构造
~string() -- 析构
*************************
string(string&& s) -- 移动构造
*************************
~string() -- 析构
~string() -- 析构
~string() -- 析构
~string() -- 析构
~string() -- 析构

以上就是小编分享的全部内容了，如果觉得不错还请留下免费的关注和收藏
如果有建议欢迎通过评论区或私信留言，感谢您的大力支持。
一键三连好运连连哦~~