C++11的部分内容（上）

一.列表初始化

1.传统的{}

例如：

cpp 复制代码

#include<iostream>
using namespace std;
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;
}

2.C++11中的{}

首先，我们实现一个大框架：

cpp 复制代码

#include<iostream>
#include<vector>
#include<map>
using namespace std;
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()
{
    ...
    return 0;
}

有了这个框架后，下面的代码都是在这个框架内实现的。

2.1.特点：

<1>.C++11以后想统一初始化方式，试图实现⼀切对象皆可用{}初始化，{}初始化也叫做列表初始化。

例如：

cpp 复制代码

int a = 2;
int b = { 2 };
cout << a << " " << b;

但是：

cpp 复制代码

int a = 1.1;  
int b = { 1.1 };

这样实现的话，编译器就会对b的初始化报错。

解释：a 变成 1（传统的隐式转换）,使用()（内置类型初始化可以直接int a(1)）初始化时，如果发生数据丢失，仅会警告，收窄转换时（比如浮点数转换为整型就是窄化转换，是错误的，但是整型转化为整型就是宽化转换，是可以的 ）使用{}初始化时，如果发生数据丢失，会报错。

<2>.自定义类型也支持，自定义类型本质是类型转换，中间会产生临时对象，最后优化了以后变成直接构造。

例如：

cpp 复制代码

Date d1(2026, 3, 12);
Date d2 = { 2026, 3, 12 };

解释：这里d2本质是用{ 2026, 3, 12 }构造⼀个Date临时对象，临时对象再去拷贝构造d2，编译器优化后合⼆为⼀变成{ 2026, 3, 12 }直接构造初始化，运行⼀下，我们可以验证上面的理论，发现是没调用拷贝构造的。

运行结果：

注意：非常量引用的初始值必须为左值,{ 2026, 3, 12 }本质上是右值，生命周期仅在这一行，要用const引用延长生命周期，右值后面讲。

例如：

cpp 复制代码

Date&d3= { 2026, 3, 12 };
const Date& d4 = { 2026, 3, 12 };

d3的引用编译器在编译时会报错。

注意：需C++98支持单参数时类型转换，也可以不用{}。

例如：

cpp 复制代码

Date d5 = { 2025 };
Date d6 = 2025;

<3>. {}初始化的过程中，可以省略掉=。

例如：

cpp 复制代码

int x1{ 2 };
Date d7{ 2024, 7, 25 };
const Date& d8{ 2024, 7, 25 };

注意：

cpp 复制代码

Date d9 2025;

<4>. C++11列表初始化的本意是想实现一个大统一的初始化方式，其次他在有些场景下带来的不少便利，如容器push/inset多参数构造的对象时，{}初始化会很方便。

例如：

cpp 复制代码

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

3.C++11中的initializer_list

上面的初始化已经很方便，但是对象容器初始化还是不太方便，比如⼀个vector对象，我想用N个值去构造初始化，那么我们得实现很多个构造函数才能支持。

特点：

<1>. C++11库中提出了⼀个std::initializer_list的类， auto il = { 10, 20, 30 }; 这个类的底层开⼀个数组，将数据拷贝过来，std::initializer_list内部有两个指针（分别为first与last）分别指向数组的开始和结束。

<2>. 这是他的文档：initializer_list - C++ 参考，std::initializer_list支持迭代器遍历。

例如：

cpp 复制代码

initializer_list<int> mylist = { 1,6,9,8,7,3,4,3,0 };
initializer_list<int>::iterator it = mylist.begin();
while (it != mylist.end())
{
    cout << *it << " ";
    it++;
}

<3>.容器支持⼀个std::initializer_list的构造函数，也就支持任意多个值构成的初始化。STL中的容器⽀持任意多个值构成的 {x1,x2,x3...} 进行 {x1,x2,x3...} 进行初始化，就是通过std::initializer_list的构造函数支持的。

例如vector的initializer_list的构造底层：

cpp 复制代码

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用initializer_list构造时，是将数组里的数据逐渐插入vector里面，当first=last时，就停止。

两者的比较：

cpp 复制代码

vector<int> v1({ 1,2,3,4,5 });
vector<int> v2 = { 1,2,3,4,5 };

解释：这两个写法语义上还是有差别的，第⼀个v1是直接构造，用的是initializer_list初始化
第⼆个v2是构造临时对象+临时对象拷贝v2 +优化为直接构造,用的是{}初始化。

二.右值引用和移动语义

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

1.左值和右值

1.1.左值

特点：左值是⼀个表示数据的表达式(如变量名或解引用的指针)，⼀般是有持久状态，存储在内存中，获取它的地址，左值可以出现赋值符号的左边，也可以出现在赋值符号右边，定义时const 修饰符后的左值，不能给他赋值，但是可以取它的地址。

例如：

cpp 复制代码

int* p = new int(0);
int b = 1;
const int c = b;
*p = 10;
string s("111111");
s[0] = 'x';
cout << &c << endl;

注意：如果我们直接&s[0]，虽然&s[0]是char*类型，但是cout对字符指针（char* 或 const char*）做了特殊的运算符重载，当cout遇到char*类型的指针时，它不会像对待int*或double*那样打印出一串十六进制的内存地址，相反，它会认为这是一个 C 风格的字符串，并从这个地址开始一直打印字符，直到遇到字符串结束符为止。

cpp 复制代码

cout << &s[0] << endl;

直接这样的结果是s的字符串。

而如果确实想查看s[0]在内存中的十六进制地址，你需要骗过cout，不让它认为这是一个字符串。方法是将强制转换为无类型指针。

cpp 复制代码

cout << (void*) & s[0] << endl;

1.1.1.左值引用给左值取别名

特点： Type& r1 = x;，左值引用就是给左值取别名，左值引用不能直接引用右值，但是const左值引用可以引用右值

例如：

cpp 复制代码

int& r1 = b;
int*& r2 = p;
int& r3 = *p;
string& r4 = s;
char& r5 = s[0];

左值引用不能直接引用右值，但是const左值引用可以引用右值，例如：

cpp 复制代码

const int& rx1 = 10;
const double& rx2 = x + y;
const double& rx3 = fmin(x, y);
const string& rx4 = string("11111");

1.2.右值

特点：右值也是⼀个表示数据的表达式，要么是字面值常量、要么是表达式求值过程中创建的临时对象等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。

例如：

cpp 复制代码

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;

上面的取地址均是错误的。

1.2.1.右值引用

特点：Type&& rr1 = y;，右值引用就是给右值取别名，右值引用不能直接引用左值，但是右值引用可以引用move(左值)，而move是库里面的⼀个函数模板，本质内部是进行强制类型转换。

例如：

cpp 复制代码

int&& rr1 = 10;
double&& rr2 = x + y;
double&& rr3 = fmin(x, y);
string&& rr4 = string("11111");

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

cpp 复制代码

int&& rrx1 = move(b);
int*&& rrx2 = move(p);
int&& rrx3 = move(*p);
string&& rrx4 = move(s);
string&& rrx5 = (string&&)s;

注意：需要注意的是变量表达式都是左值属性，也就意味着⼀个右值被右值引用绑定后，右值引用变量变量表达式的属性是左值（后面会讲原因）。

1.3.两者差异

<1>.左值的英文简写为lvalue，右值的英文简写为rvalue。传统认为它们分别是left value、right value 的缩写。现代C++中，lvalue被解释为loactor value的缩写，可意为存储在内存中、有明确存储地址可以取地址的对象 ，而rvalue被解释为read value，指的是那些可以提供数据值，但是不可以寻址 ，例如：临时变量，字面量常量，存储于寄存器中的变量等，也就是说左值和右值的核心区别就是能否取地址。

<2>.语法层面看，左值引用和右值引用都是取别名，不开空间。从汇编底层的角度看下面代码中r1和rr1 汇编层实现，底层都是用指针实现的，没什么区别。底层汇编等实现和上层语法表达的意义有时是背离的，所以不要然到⼀起去理解，互相佐证，这样反而是陷⼊迷途

<3>.右值引用可用于为临时对象延长生命周期，const的左值引用也能延长临时对象生存期，但这些对象无法被修改。

例如：

cpp 复制代码

#include<iostream>
using namespace std;
int main()
{
	string s1 = "Test";
	// string&& r1 = s1;           // 错误：不能绑定到左值

	const string& r2 = s1 + s1;    // OK：到const的左值引⽤延⻓⽣存期
	//  r2 += "Test";              // r2不可以修改      

	string&& r3 = s1 + s1;         // OK：右值引⽤延⻓⽣存期

	r3 += "Test";                  // OK：能通过到⾮const的引⽤修改

	cout << r3 << '\n';

	return 0;
}

<4>.左值和右值的参数匹配时，右值引用变量在用于表达式时属性是左值。

例如：

cpp 复制代码

#include<iostream>
using namespace std;
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;
}

2.右值引用和移动语义的使用场景

1.左值引用主要使用场景

左值引用主要使用场景是在函数中左值引用传参和左值引用传返回值时减少拷贝，同时还可以修改实参和修改返回对象的价值。左值引用已经解决大多数场景的拷贝效率问题，但是有些场景不能使用传左值引用返回，如addStrings和generate函数，C++98中的解决方案只能是被迫使用输出型参数解决。那么C++11以后这里可以使用右值引用做返回值解决吗？显然是不可能的，因为这里的本质是返回对象是⼀个局部对象，函数结束这个对象就析构销毁了，右值引用返回也无法概念对象已经析构销毁的事实。

例如在String.h · 无忧.芙桃/C++学习之路.cpp - Gitee.com里面，有一个简单的string的底层，而

cpp 复制代码

#include"String.h"
lass Solution {
public:
	// 传值返回需要拷贝
	kong::string addStrings(kong::string num1, kong::string num2) {
		kong::string str;
		int end1 = num1.size() - 1, end2 = num2.size() - 1;
		// 进位
		int next = 0;
		while (end1 >= 0 || end2 >= 0)
		{
			int val1 = end1 >= 0 ? num1[end1--] - '0' : 0;
			int val2 = end2 >= 0 ? num2[end2--] - '0' : 0;
			int ret = val1 + val2 + next;
			next = ret / 10;
			ret = ret % 10;
			str += ('0' + ret);
		}
		if (next == 1)
			str += '1';
		reverse(str.begin(), str.end());
		cout << "str的地址：" << &str << endl;
		return str;
	}
};
int main()
{
   kong::stringret=Solution().addStrings("11111111111111111111",
"222222222222222222222222222");
	cout <<"ret的地址：" << &ret << endl;
	cout << &ret<< endl;

	return 0;
}

注意：可能有人会认为使用string&类减少拷贝，但是string引用的是已经销毁的str，这会导致野引用，又有人认为使用const string&/string&&来延长str的生命周期，但是str始终在这个栈中，函数结束后，栈就销毁了，这也是不可取的。

建议：不要返回局部变量的引用。

2.移动构造和移动赋值

移动构造函数是⼀种构造函数，类似拷贝构造函数，移动构造函数要求第⼀个参数是该类类型的引用，但是不同的是要求这个参数是右值引用，如果还有其他参数，额外的参数必须有缺省值。

• 移动赋值是⼀个赋值运算符的重载，他跟拷贝赋值构成函数重载，类似拷贝赋值函数，移动赋值函数要求第⼀个参数是该类类型的引用，但是不同的是要求这个参数是右值引用。

• 对于像string/vector这样的深拷贝的类或者包含深拷贝的成员变量的类，移动构造和移动赋值才有意义，因为移动构造和移动赋值的第⼀个参数都是右值引用的类型，他的本质是要"窃取"引用的右值对象的资源，而不是像拷贝构造和拷贝赋值那样去拷贝资源，从提高效率，我们需要结合上面的场景理解。

注意：图片里的string都是kong里的string，方便观察

输出结果的 编译环境为VS2022的debug

2.1.右值对象构造，只有拷贝构造，没有移动构造的场景

输出结果：

解释：num1,num2先拷贝构造"11111","2222"构造出的临时对象，编译器优化后直接变为构造；

编译器优化前，str调用构造，返回str前，有一个临时对象，临时对象拷贝构造str,返回后，str销毁了，而ret拷贝构造的是临时对象；

如图：vs2019debug优化后直接将临时对象删了，变ret拷贝构造str；

如图：
vs2022后优化后，变为str是ret的引用，仅调用ret的构造函数，可以通过str与ret的地址证明。

如图：

2.2.右值对象构造，有拷贝构造，也有移动构造的场景

输出结果：

解释：

<1>.num1,num2先移动构造"11111","2222"构造出的临时对象，编译器优化后直接变为构造，编译器优化前，str调用构造，返回str前，有一个临时对象，临时对象移动构造str,返回后，str销毁了，而ret移动的是临时对象；

如图：
<2>.vs2019debug优化后直接将临时对象删了，变ret移动构造str；

如图：
<3>.vs2022后优化后，变为str是ret的引用，仅调用ret的构造函数，可以通过str与ret的地址证明。

如图：

可能有人会认为既然有了编译器的优化，那移动构造与拷贝构造的效率并不是很大，那如果是：

cpp 复制代码

bit::string ret;
ret = bit::addStrings("11111", "2222");
cout << "ret的地址:" << &ret << endl;
cout << ret.c_str() << endl;

这时就需要调用赋值函数了。

2.3.右值对象赋值，只有拷贝构造和拷贝赋值，没有移动构造和移动赋值的场景

输出结果：

解释：num1,num2先拷贝构造"11111","2222"构造出的临时对象，编译器优化后直接缩减为构造
编译器优化前，str调用构造，返回str前，有一个临时对象，临时对象拷贝构造str,返回后，str销毁了，而ret赋值的是临时对象；

如图：
vs2019debug和vs2022后优化后，将拷贝构造+构造直接变为构造，先构造临时对象，而str是临时对象的引用，ret再赋值拷贝那个临时对象；

如图：

由此可以看出：编译器优化后也还是有限制。

2.4.右值对象赋值，既有拷贝构造和拷贝赋值，也有移动构造和移动赋值的场景

输出结果：

解释：

<1>.num1,num2先移动构造"11111","2222"构造出的临时对象，编译器优化后直接变为构造
编译器优化前，str调用构造，返回str前，有一个临时对象，临时对象移动构造str,返回后，str销毁了，而ret移动的是临时对象；

如图：
<2>.需要注意的是在vs2019的release和vs2022，会进⼀步优化，直接构造要返回的临时对象，str本质是临时对象的引用，底层角度用指针实现。

如图：

我们也可以将析构函数的cout注释去掉，这样验证临时变量的存在：

输出结果：

运行结果的角度，我们可以看到str的析构是在赋值以后，说明str就是临时对象的别名。

3.其他的问题

3.1.解释为什么str的析构是在赋值以后？

原因：优化前：main函数预留一块空间给临时对象 Temp，调用addStrings，开辟addStrings的栈帧，在 addStrings 栈帧内，分配内存给 str，返回时，把 addStrings栈帧里str 的数据，拷贝到Temp里的，销毁addStrings栈帧内的str ，弹出栈帧；优化后：main函数在自己的栈帧里，开辟了临时对象 Temp 的内存，main函数把 Temp 的内存地址当作隐藏参数，传给 addStrings，在内部，你以为你在操作局部变量 str，其实你是在通过隐藏指针，直接跨栈帧修改 main 函数里的 Temp，当addStrings执行完毕，弹出栈帧时，只有num1，``num2这些真正的局部变量被销毁了，而str （实际上是外部的 Temp）因为活在的栈帧里，它不受str``main``addStrings 栈帧销毁的影响，它必须等到 main函数里这行代码ret 的赋值动作做完,遇到分号时，才会被销毁。

3.2.为什么右值引用变量的属性是左值？

原因：右值引用相当于有了一个空间将右值存储了起来，确保这个临时对象的内存不会在分号处被销毁，而这个变量名就成了这块空间的合法标识符，我们也可以取这个右值引用变量的地址，但是如果右值引用变量的属性还是是右值的化，假如：

cpp 复制代码

string(string&& s) 
{
    // 第一次掠夺：匹配到 swap(string&& ss)
    // 假设在这个 swap 里，资源已经通过指针交换被拿走了
    swap(s); 

    // 第二次掠夺（最危险的地方）：
    // 因为 s 还是右值属性，如果你不小心又写了下面这行
    // 编译器会再次隐式匹配【移动构造】，尝试再次从 s 身上"偷"资源
    string other = s; 
}

此时s已经是被掏空的"僵尸"了，第二次掠夺会导致程序去操作一个非法的、已经失去所有权的对象，这是极其危险的。