前言
c++11 标准的发布为 c++ 带来了革命性的变化，引入了许多强大的新特性，使代码更简洁、高效且现代化。这些特性不仅提升了开发效率，还优化了性能，是现代 c++ 编程的重要基石。本篇文章，我们将重点探讨 c++11 的几个核心改进：列表初始化、右值引用和移动语义、类的新默认成员函数以及lambda表达式。
一、列表初始化
1. 大括号初始化
在c++98中，允许数组和结构体使用大括号初始化，例如：
#include <iostream>
using namespace std;
struct STU
{
int a;
double b;
};
int main()
{
int arr[5] = {
1,2,3,4,5 };
STU s = {
3,5.5 };
return 0;
}
而在c++11之后，统一了初始化方式，“ 一切对象 ”均可以用大括号进行初始化（也叫做列表初始化），十分方便。举例：
int a = {
2 };
const STU& rs = {
3,5.5 };
对于自定义类型，使用大括号初始化本质是一种隐式类型转换，会产生临时对象，不过很多编译器会将其进行优化为直接构造对象。
注意：使用大括号初始化时，赋值符号可以省略。
int a{
1 };
STU s{
2,3.1 };
const STU& rs{
3,5.5 };
c++11的大括号初始化方式，也在某些场景下带来了许多便利，例如调用容器接口操作多参数类型构造的对象时：
#include <iostream>
#include <vector>
#include <string>
using namespace std;
int main()
{
vector<pair<string, int>> v;
v.push_back({
"hello", 1 });
return 0;
}
2. initializer_list
虽然刚才提到的大括号初始化已经十分方便，但是对于容器的多元素初始化，仍旧有些麻烦。所以c++11引入了一个新容器 -- initializer_list（初始化列表/初始化器），并在STL各种容器中增加了有它支持的构造函数、拷贝构造函数和赋值重载。代码示例：
#include <iostream>
#include <vector>
#include <list>
#include <map>
using namespace std;
int main()
{
vector<int> v = {
1,2,3,4,5 };
list<double> l = {
3.1,5.2,4.8 };
map<string, int> m = {
{
"hello", 1}, {
"hehe", 3} };
return 0;
}
这里赋值使用的大括号及其内部元素，即是initializer_list。它也有自己的定义方式：
auto il1 = {
1,2,3,4,5 };
initializer_list<int> il2 = {
1,2,3,4,5 };
initializer_list的本质是一个数组，其元素存放在栈区当中，它的迭代器是原生指针，内部有两个迭代器分别指向其开始位置和结束位置。我们使用它对容器进行构造或赋值时，是构造了一个initializer_list的对象，然后调用容器的相应函数去遍历initializer_list，一个个地构造。
二、右值引用和移动语义
在某些情况下，使用传统的左值引用，并不能提高效率：
vector<string> v;
v.push_back("hello");
而在c++11当中，引入了一种新的引用--右值引用。
1. 左值和右值
左值：一般是一个持久存在的表达式， 有明确内存地址，可以进行取地址操作。左值既可以放在赋值号左边，也可以放在赋值号右边。
右值：指那些临时性的，即将被销毁的，以及常量表达式，没有明确的内存地址，不能进行取地址操作。右值不能放在赋值号左边。
2. 左值引用和右值引用
顾名思义，左值引用是给左值取别名，右值引用是给右值取别名。举个例子：
#include <iostream>
using namespace std;
int main()
{
int a = 0;
int& r1 = a;
int&& r2 = 1;
return 0;
}
左值引用不能直接引用右值，需要加上const；右值引用不能直接引用左值，需要将左值使用move函数包装起来（move将左值转化为右值引用）。示例：
#include <iostream>
using namespace std;
int main()
{
const int& r1 = 1;
int a = 0;
int&& r2 = (int&&)a;
int&& r3 = move(a);
return 0;
}
需要注意：这里的 r2 和 r3 虽然是右值引用，但是 r2 和 r3 本身还是左值，是可以取到地址的。
在语法层面上看，左值引用和右值引用都是给变量或常量取别名，不会开辟内存。但是从底层实现的角度上讲，左值引用和右值引用本质都是用指针实现的，与指针并没有什么区别。我们在学习语法的时候，语法所表达的意义与底层可能是背离的，尽量不要混到一起，容易陷入迷途。
引用延长生命周期
const左值引用和右值引用都可以延长临时对象的生命周期，直至引用的生命周期结束，但const左值引用所引用的对象不可被修改；而通过右值引用，可以修改所引用的临时对象，因为右值引用本身是左值。
示例：
#include <iostream>
using namespace std;
int main()
{
const int& r1 = 1 + 3;
r1++;
int&& r2 = 1 + 3;
r2++;
return 0;
}
左值引用和右值引用的参数匹配原则
在c++98当中，被const修饰的左值引用形参既可以接收左值，也可以接收右值。而在c++11当中，由于引入了右值引用，所以当同时存在两个形参分别为右值引用和const的左值引用的重载函数时，**如果我们传入左值，那么会优先调用const左值引用的重载函数；如果传入右值，则会优先调用右值引用版本的重载函数**。
代码示例：
#include <iostream>
using namespace std;
void func(const int& x)
{
cout << "调用左值引用" << endl;
}
void func(int&& x)
{
cout << "调用右值引用" << endl;
}
int main()
{
int a = 0;
func(a);
func(1);
func(move(a));
return 0;
}
注意：在右值引用版本的重载函数中，参数x的性质是左值（之前已经提到），所以如果要将x作为参数传入一个形参是右值引用的函数中，需要使用move或强转为右值引用类型。
那么，右值引用存在的意义是什么呢？实际上右值引用的核心价值在于支持移动语义，主要体现在移动构造和移动赋值这两个新默认成员函数中。我们具体分析一下。
右值引用的适用场景
虽然说左值引用可以在对象的传参和返回时减少拷贝，提高效率。但如果对象在函数体内部创建，其离开函数体时就会销毁。如果要传值返回或强行传引用返回，就会发生拷贝/出现野引用。
此时右值引用的作用就体现出来了：右值引用可以接收即将被销毁的对象，再以左值的形式，在对象销毁之前，配合移动构造或移动赋值，将对象的资源直接移走，避免拷贝，从而提效。
string类的移动构造和移动赋值实现示例：
string(string&& s)
{
swap(s);
}
string& operator=(string&& s)
{
swap(s);
return *this;
}
有了移动构造，函数体内部定义的对象传值返回后，由于返回值是即将销毁的对象，会被移动构造给临时对象，临时对象再移动构造/移动赋值给当前接收对象，这样就完成了两次资源转移，在没有编译器优化的情况下也避免拷贝。
传参时，如果传入临时对象，也会通过移动构造直接将资源进行移动，免去了对象拷贝时的时间消耗。
注意：如果我们将左值经过move转化传给移动构造，那么左值的资源会被掠夺。
string s2 = move(s1); // 此时s1的资源被掠夺
引用折叠与万能引用
c++不能直接定义引用的引用，但我们可以使用typedef的方式间接定义引用的引用，称之为引用折叠。示例：
#include <iostream>
using namespace std;
typedef int& lr;
typedef int&& rr;
int main()
{
int a = 0;
lr& r1 = a;
lr&& r2 = a;
rr& r3 = a;
rr&& r4 = 1;
return 0;
};
这样就会产生四种甚至更多的引用类型，显得十分杂乱。为了使这种语法兼具实用性和简洁性，c++规定引用折叠的规则是：右值引用的右值引用表示右值引用，其余均表示左值**引用。**所以这里的r1,r2,r3都是左值引用，r4是右值引用。
引用折叠的机制与模板相结合，产生了“万能引用”：
template<class T>
void func(T&& x)
{
}
当给func函数传入左值时，T会被实例化为左值引用类型，与右值引用折叠成左值引用；**当传入右值时，T会被实例化为右值类型，与“&&”结合形成右值引用。**
万能引用使得模板函数在接受参数时既能处理左值，也能处理右值，使代码更具灵活性和可扩展性。
完美转发
如果我们给万能引用函数传入右值，由于右值引用变量本身是左值，所以如果用这个右值引用在内部嵌套调用其他函数，就无法保持参数的属性（传入的其实为左值），从而无法达到预期效果。为此C++提供了一个函数forward（完美转发），保持属性。
示例：
#include <iostream>
#include <utility>
using namespace std;
void func2(int& x)
{
cout << "左值版本" << endl;
}
void func2(int&& x)
{
cout << "右值版本" << endl;
}
template<class T>
void func1(T&& x)
{
func2(x);
func2(forward<T>(x));
}
int main()
{
func1(1);
return 0;
}
运行结果：
这里我们想要将func1的右值引用形参x传给func2，并调用func2的右值引用版本，但是x作为右值引用，语法规定其本身是左值类型，所以直接传入就会调用func2的左值引用版本。完美转发保持了x的右值属性，方便我们正确调用函数。
完美转发的本质是一个函数模板，它基于模板参数T的类型，决定是否使用move将左值转化为右值，从而保持原始参数的值属性，确保不会因为出现左值引用而产生不必要的临时对象拷贝，避免降低效率。
三、类的新默认成员函数
c++11在原有的六个默认成员函数的基础上，新增了两个函数：移动构造函数和移动赋值函数。之前已经提到了它们面对临时对象拷贝时的优势，这里我们再系统介绍一下这两个函数的特点。
1. 移动构造函数
移动构造函数是构造函数的一个重载，类似于拷贝构造函数，主要用于提高临时对象拷贝时的性能。它的特性如下：
1. 移动构造函数的第一个参数必须是该类类型的右值引用，如果还有其他参数，要求这些参数要有缺省值。
2. 如果我们没有显式实现移动构造函数，也没有显式实现析构函数、拷贝构造和赋值重载，那么编译器会默认生成一个移动构造函数。这个自动生成的移动构造函数进行移动构造时，如果遇到内置类型成员，会逐个拷贝；遇到自定义类型的成员，则会调用该成员的移动构造。如果该成员没有移动构造，则会调用其拷贝构造。
string(string&& s)
{
swap(s);
}
2. 移动赋值函数
与赋值重载类似，移动赋值对已经存在的对象的赋值，并且会将对方的资源移走。它的特性：
1. 移动赋值必须重载为成员函数，且其第一个参数必须是该类类型的右值引用，一般情况下，将返回值类型设置为该类类型的左值引用，减少拷贝提高效率。
2. 如果我们没有显式实现移动赋值函数，也没有显式实现析构函数、拷贝构造和赋值重载，那么编译器会默认生成一个移动赋值函数。这个自动生成的移动赋值函数进行移动赋值时，如果遇到内置类型成员，会逐个拷贝；遇到自定义类型的成员，则会调用该成员的移动赋值。如果该成员没有移动赋值，则会调用其赋值重载。
string& operator=(string&& s)
{
swap(s);
return *this;
}
注意：对于内部需要动态申请资源，要进行资源深拷贝的类，移动构造和移动赋值才有意义，因为移动构造和移动赋值的本质是“窃取”临时对象的资源，而不是像拷贝构造或赋值重载那样去完成资源的深拷贝，这样才能提高效率。
四、lambda表达式
lambda表达式与仿函数类似，是c++11新引入的一种匿名函数对象。与普通函数不同的是，它可以定义在函数体内部。
它的语法格式如下：
\捕捉列表->返回**值类型**{函数体}
示例：
#include <iostream>
using namespace std;
int main()
{
auto f = ->int {
return x + y; };
cout << f(1, 2) << endl;
return 0;
}
注意：lambda表达式的类型在语法层面是不具体的，所以我们一般用auto或者模板参数定义的对象类型去接收lambda表达式。
这里使用 f 接收lambda表达式以后，我们就可以像调用函数一样调用 f ，并且进行传参。
在定义lambda表达式时，有如下规则需要我们遵守：
1. 捕捉列表的“[ ]”不能省略。
2. lambda表达式的参数为空时，参数列表（包括“( )”）可以省略。
3. 返回值类型（包括“->”）可以省略。
4. 若返回值类型已写，那么就算没有参数，参数列表的“( )”也不能省略。
5. 函数体的“{ }”不能省略。
lambda表达式中的参数列表、返回值类型与函数体都很好理解（与普通函数的含义相同），但是这里的捕捉列表是什么呢？
1. 捕捉列表
就像函数一样，lambda表达式的函数体只能使用其对应参数列表中的变量，无法使用到外部变量。而捕捉列表可以让我们在lambda表达式的函数体当中使用外层变量。
捕捉一共分为三种，分别是显式捕捉、隐式捕捉和混合捕捉。
显式捕捉
显式捕捉就是在捕捉列表当中显式写明要在函数体中使用的变量。示例：
#include <iostream>
using namespace std;
int main()
{
int a = 1;
int b = 3;
auto f = a
{
return a + x;
};
cout << f(1) << endl;
return 0;
}
当然，如果我们要在函数体内部修改变量a的值，是不允许的（因为这里的a是传值捕捉）。如果要修改a的值，那么需要传引用捕捉：
auto f = &a // a前面加一个&
隐式捕捉
相比显式捕捉，隐式捕捉就显得十分便利：它的机制是函数体内部使用了哪些变量就捕捉哪些变量。 隐式捕捉也分为传值捕捉和传引用捕捉：
auto f1 = [=] {
};
auto f2 = [&] {
};
使用了隐式捕捉之后，我们就可以在函数体内部任意使用外部的变量，编译器会根据我们使用的变量自动捕捉它们。
混合捕捉
如果我们需要在隐式捕捉的基础上，确保其中某些值可以被修改或不能被修改，那么就可以使用混合捕捉。示例如下：
auto f1 = [=, &a] {
};
auto f2 = [&, a] {
};
注意：混合捕捉当中，捕捉列表的第一个位置必须是“=”或“&”；如果混合捕捉的隐式部分使用了传值捕捉，那么其他特定变量就不能设置为传值捕捉（没必要），传引用捕捉同上。
捕捉列表的其他要点
1. 全局变量和静态变量不能捕捉，也没必要捕捉，可以直接使用。
2. 对于传值捕捉，其本质是将外层数据进行拷贝，并加上const进行修饰，所以函数体内部没办法修改它。如果想要修改捕捉的值，而不影响外部，可以在参数列表之后，返回值类型之前加上关键字mutable。示例：
#include <iostream>
using namespace std;
int main()
{
int a = 0;
auto f = = mutable ->int
{
a++;
return a;
};
return 0;
}
注意：加上关键字mutable后，那么就算没有参数，参数列表的“( )”也不能省略。
2. lambda表达式的适用场景
在lambda表达式出现之前，可调用对象只有函数指针和仿函数两种，但它们定义起来都比较麻烦。lambda和它们的作用类似，功能也十分强大，在某些场景下编码也会更加方便（因为它是匿名函数对象）。 示例：
sort(a.begin(), a.end(),
{
});
除此之外，lambda在线程中定义线程的执行函数逻辑、智能指针的删除器定义等场景中也十分适用。
总结
本篇文章，我们主要学习了c++11的部分新特性：列表初始化、右值引用、类的新默认成员函数和lambda表达式。通过剖析引用折叠、完美转发等底层机制，lambda的多种捕捉方式与适用场景，希望能帮助大家在资源管理、代码简洁性及性能提升之间找到平衡。之后博主会和大家分享c++11其他的新特性，如可变参数模板、包装器、智能指针等。如果你觉得博主讲的还不错，就请留下一个小小的赞在走哦，感谢大家的支持❤❤❤
