【C++笔记】C+11深度剖析(三)

🔥个人主页：大白的编程日记

🔥专栏：C++笔记

---

前言

哈喽，各位小伙伴大家好!上期我们讲了C+11深度剖析(二)。今天我们来讲一下C+11深度剖析(三)。话不多说，我们进入正题！向大厂冲锋

一. lambda

1.1 lambda表达式语法

• lambda 表达式本质是⼀个匿名函数对象，跟普通函数不同的是他可以定义在函数内部。lambda 表达式语法使用层而言没有类型，所以我们⼀般是用auto或者模板参数定义的对象去接收 lambda 对象。
• lambda表达式的格式： [capture-list] (parameters)-> return type {function boby }
• [capture-list] : 捕捉列表，该列表总是出现在 lambda 函数的开始位置，编译器根据[]来判断接下来的代码是否为 lambda 函数，捕捉列表能够捕捉上下文中的变量供 lambda 函数使用，捕捉列表可以传值和传引用捕捉，具体细节7.2中我们再细讲。捕捉列表为空也不能省略。
• (parameters) ：参数列表，与普通函数的参数列表功能类似，如果不需要参数传递，则可以连同()⼀起省略
• ->return type ：返回值类型，用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。⼀般返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。
• {function boby} ：函数体，函数体内的实现跟普通函数完全类似，在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量，函数体为空也不能省略。

int main()
{
 // ⼀个简单的lambda表达式
 auto add1 = [](int x, int y)->{return x + y; };
 cout << add1(1, 2) << endl;
 // 1、捕捉为空也不能省略
 // 2、参数为空可以省略
 // 3、返回值可以省略，可以通过返回对象⾃动推导
 // 4、函数题不能省略
 auto func1 = []
	 {
		 cout << "hello bit" << endl;
		 return 0;
	 };
 //func1();
 int a = 0, b = 1;
 auto swap1 = [](int& x, int& y)
	 {
		 int tmp = x;
		 x = y;
		 y = tmp;
	 };
 swap1(a, b);
 //cout << a << ":" << b << endl;
 return 0;
}
#include<vector>
 using namespace std;
 struct Goods
 {
	 string _name; // 名字
	 double _price; // 价格
	 int _evaluate; // 评价
	 // ...
	 Goods(const char* str, double price, int evaluate)
		 :_name(str)
		 , _price(price)
		 , _evaluate(evaluate)
	 {}
 };
 struct ComparePriceLess
 {
	 bool operator()(const Goods& gl, const Goods& gr)
	 {
		 return gl._price < gr._price;
	 }
 };
 struct ComparePriceGreater
 {
	 bool operator()(const Goods& gl, const Goods& gr)
	 {
		 return gl._price > gr._price;
	 }
 };
 int main()
 {
	 vector<Goods> v = { { "苹果", 2.1, 5 }, { "⾹蕉", 3, 4 }, { "橙⼦", 2.2, 3
	 }, { "菠萝", 1.5, 4 } };
	 // 类似这样的场景，我们实现仿函数对象或者函数指针⽀持商品中
	 // 不同项的⽐较，相对还是⽐较⿇烦的，那么这⾥lambda就很好⽤了
	 sort(v.begin(), v.end(), ComparePriceLess());
	 sort(v.begin(), v.end(), ComparePriceGreater());
	 sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
		 return g1._price < g2._price;
		 });
	 sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
		 return g1._price > g2._price;
		 });
	 sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
		 return g1._evaluate < g2._evaluate;
		 });
	 sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
		 return g1._evaluate > g2._evaluate;
		 });
	 return 0;
 }

1.2 捕捉列表

• lambda 表达式中默认只能用 lambda 函数体和参数中的变量，如果想用外层作用域中的变量就需要进行捕捉
• 第⼀种捕捉方式是在捕捉列表中显示的传值捕捉和传引引用捕捉，捕捉的多个变量用逗号分割。[x，y， &z] 表示x和y值捕捉，z引用捕捉。
• 第⼆种捕捉方式是在捕捉列表中隐式捕捉，我们在捕捉列表写⼀个=表示隐式值捕捉，在捕捉列表写⼀个&表示隐式引用捕捉，这样我们 lambda 表达式中用了那些变量，编译器就会自动捕捉那些变量。
• 第三种捕捉方式是在捕捉列表中混合使用隐式捕捉和显示捕捉。[=, &x]表示其他变量隐式值捕捉，x引用捕捉；[&, x, y]表示其他变量引用捕捉，x和y值捕捉。当使用混合捕捉时，第⼀个元素必须是&或=，并且&混合捕捉时，后面的捕捉变量必须是值捕捉，同理=混合捕捉时，后面的捕捉变量必须是引用捕捉。
• lambda 表达式如果在函数局部域中，他可以捕捉 lambda 位置之前定义的变量，不能捕捉静态局部变量和全局变量，静态局部变量和全局变量也不需要捕捉， lambda 表达式中可以直接使用。这也意味着 lambda 表达式如果定义在全局位置，捕捉列表必须为空。
• 默认情况下， lambda 捕捉列表是被const修饰的，也就是说传值捕捉的过来的对象不能修改，mutable加在参数列表的后面可以取消其常量性，也就说使用该修饰符后，传值捕捉的对象就可以修改了，但是修改还是形参对象，不会影响实参。使用该修饰符后，参数列表不可省略(即使参数为空)。

 捕捉列表必须为空，因为全局变量不⽤捕捉就可以⽤，没有可被捕捉的变量
int main()
{
 // 只能⽤当前lambda局部域和捕捉的对象和全局对象
 int a = 0, b = 1, c = 2, d = 3;
 auto func1 = [](int a, int b) {return a + b; };
 auto func1 = [a, &b]
{
	// 值捕捉的变量不能修改，引⽤捕捉的变量可以修2改
	//a++;
	b++;
	int ret = a + b;
	return ret;
};
 cout << func1() << endl;
 // 隐式值捕捉
 // ⽤了哪些变量就捕捉哪些变量
 auto func2 = [=]
{
	int ret = a + b + c;
	return ret;
};
 cout << func2() << endl;
 // 隐式引⽤捕捉
 // ⽤了哪些变量就捕捉哪些变量
 auto func3 = [&]
{
	a++;
	c++;
	d++;
};
 func3();
 cout << a << " " << b << " " << c << " " << d << endl;
 // 混合捕捉1
 auto func4 = [&, a, b]
{
	//a++;
	//b++;
	c++;
	d++;
	return a + b + c + d;
};
 func4();
 cout << a << " " << b << " " << c << " " << d << endl;
 // 混合捕捉1
 auto func5 = [=, &a, &b]
{
	a++;
	b++;
	/*c++;
	d++;*/
	return a + b + c + d;
};
 func5();
 cout << a << " " << b << " " << c << " " << d << endl;
 // 局部的静态和全局变量不能捕捉，也不需要捕捉
 static int m = 0;
 auto func6 = []
{
	int ret = x + m;
	return ret;
};
 // 传值捕捉本质是⼀种拷⻉,并且被const修饰了
 // mutable相当于去掉const属性，可以修改了
 // 但是修改了不会影响外⾯被捕捉的值，因为是⼀种拷⻉
 auto func7 = [=]()mutable
{
	a++;
	b++;
	c++;
	d++;
	return a + b + c + d;
};
 cout << func7() << endl;
 cout << a << " " << b << " " << c << " " << d << endl;
 return 0;
}

1.3 lambda的原理

• lambda 的原理和范围for很像，编译后从汇编指令层的角度看，压根就没有 lambda 和范围for这样的东西。范围for底层是迭代器，而lambda底层是仿函数对象，也就说我们写了⼀个lambda 以后，编译器会生成⼀个对应的仿函数的类。
• 仿函数的类名是编译按⼀定规则生成的，保证不同的 lambda生成的类名不同，lambda参数/返回类型/函数体就是仿函数operator()的参数/返回类型/函数体， lambda 的捕捉列表本质是生成的仿函数类的成员变量，也就是说捕捉列表的变量都是 lambda 类构造函数的实参，当然隐式捕捉，编译器要看使用哪些就传那些对象。
• 上面的原理，我们可以透过汇编层了解⼀下，下面第⼆段汇编层代码印证了上面的原理。

class Rate
{
public:
	Rate(double rate)
		: _rate(rate)
	{}
	double operator()(double money, int year)
	{
		return money * _rate * year;
	}
private:
	double _rate;
};
int main()
{
	double rate = 0.49;
	// lambda
	auto r2 = [rate](double money, int year) {
		return money * rate * year;
		};
	// 函数对象
	Rate r1(rate);
	r1(10000, 2);
	r2(10000, 2);
	auto func1 = [] {
		cout << "hello world" << endl;
		};
	func1();
	return 0;
}
// lambda
auto r2 = [rate](double money, int year) {
	return money * rate * year;
	};
// 捕捉列表的rate，可以看到作为lambda_1类构造函数的参数传递了，这样要拿去初始化成员变量
// 下⾯operator()中才能使⽤
00D8295C lea eax,[rate]
00D8295F push eax
00D82960 lea ecx,[r2]
00D82963 call `main'::`2'::<lambda_1>::<lambda_1> (0D81F80h)
// 函数对象
Rate r1(rate);
00D82968 sub esp,8
00D8296B movsd xmm0,mmword ptr [rate]
00D82970 movsd mmword ptr [esp],xmm0
00D82975 lea ecx,[r1]
00D82978 call Rate::Rate (0D81438h)
r1(10000, 2);
00D8297D push 2
00D8297F sub esp,8
00D82982 movsd xmm0,mmword ptr [__real@40c3880000000000 (0D89B50h)]
00D8298A movsd mmword ptr [esp],xmm0
00D8298F lea ecx,[r1]
00D82992 call Rate::operator() (0D81212h)
// 汇编层可以看到r2 lambda对象调⽤本质还是调⽤operator()，类型是lambda_1,这个类型名
// 的规则是编译器⾃⼰定制的，保证不同的lambda不冲突
r2(10000, 2);
00D82999 push 2
00D8299B sub esp,8
00D8299E movsd xmm0,mmword ptr [__real@40c3880000000000 (0D89B50h)]
00D829A6 movsd mmword ptr [esp],xmm0
00D829AB lea ecx,[r2]
00D829AE call `main'::`2'::<lambda_1>::operator() (0D824C0h)

二.新的类功能

2.1 默认的移动构造和移动赋值

• 原来C++类中，有6个默认成员函数：构造函数/析构函数/拷贝构造函数/拷贝赋值重载/取地址重载/const 取地址重载，最后重要的是前4个，后两个用处不大，默认成员函数就是我们不写编译器会生成⼀个默认的。C++11 新增了两个默认成员函数，移动构造函数和移动赋值运算符重载。
• 如果你没有自己实现移动构造函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意⼀个。那么编译器会自动生成⼀个默认移动构造。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用
  移动构造，没有实现就调用拷贝构造。
• 如果你没有自己实现移动赋值重载函数，且没有实现析构函数 、拷贝构造、拷用赋值重载中的任意⼀个，那么编译器会自动生成⼀个默认移动赋值。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造完全类似)
• 如果你提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值。

class Person
{
public:
	Person(const char* name = "", int age = 0)
		:_name(name)
		, _age(age)
	{}
	/*Person(const Person& p)
	:_name(p._name)
	,_age(p._age)
	{}*/
	/*Person& operator=(const Person& p)
	{
	if(this != &p)
	{
	_name = p._name;
	_age = p._age;
	}
	return *this;
	}*/
	/*~Person()
{}*/
private:
	bit::string _name;
	int _age;
};
int main()
{
	Person s1;
	Person s2 = s1;
	Person s3 = std::move(s1);
	Person s4;
	s4 = std::move(s2);
	return 0;
}

2.2 成员变量声明时给缺省值

成员变量声明时给缺省值是给初始化列表用的，如果没有显示在初始化列表初始化，就会在初始化列表用这个缺省值初始化。

2.3 defult和delete

• C++11可以让你更好的控制要使用的默认函数。假设你要使用某个默认的函数，但是因为⼀些原因这个函数没有默认生成。比如：我们提供了拷贝构造，就不会生成移动构造了，那么我们可以使用default关键字指定移动构造生成。

例如现在我们把析构放出来，但是可以defult强制生成移动构造和移动复制赋值

• 如果能想要限制某些默认函数的生成，在C++98中，是该函数设置成private，并且只声明补丁已，这样只要其他人想要调用就会报错。在C++11中更简单，只需在该函数声明加上=delete即可，该语法指示编译器不生成对应函数的默认版本，称=delete修饰的函数为删除函数。

例如IO流不希望背拷贝加上了=delete

2.4 final与override

• final 是一个修饰符，用于限制变量、方法或类的修改或重写。
• Override 注解用于告诉编译器，当前方法是重写了父类中的方法。如果父类中没有对应的方法，编译器会报错。它可以帮助编译器检查方法签名是否正确，避免因拼写错误或参数不匹配而导致的错误。

三.C++11后STL的变化

• 下图1圈起来的就是STL中的新容器，但是实际最有用的是unordered_map和unordered_set。这两个我们前面已经进行了非常详细的讲解，其他的大家了解⼀下即可。

• STL中容器的新接口也不少，最重要的就是右值引用和移动语义相关的push/insert/emplace系列接口和移动构造和移动赋值，还有initializer_list版本的构造等，这些前面都讲过了，还有⼀些无关痛痒的如cbegin/cend等需要时查查文档即可。

• 容器的范围for遍历，这个在容器部分也讲过了

四.包装器

4.1 function

template <class T>
class function; // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;

• std::function 是⼀个类模板，也是⼀个包装器。 std::function 的实例对象可以包装存储其他的可以调用对象，包括函数指针、仿函数、 lambda 、 bind 表达式等，存储的可调用对象被称为 std::function 的目标。若 std::function 不含目标，则称它为空。调用空std::function 的目标导致抛出 std::bad_function_call 异常。
• 函数指针、仿函数、 lambda 等可调用对象的类型各不相同， std::function 的优势就是统⼀类型，对他们都可以进行包装，这样在很多地方就方便声明可调用对象的类型，下面的第二个代码样例展示了 std::function 作为map的参数，实现字符串和可调用对象的映射表功能。

#include<functional>
int f(int a, int b)
{
	return a + b;
}
struct Functor
{
public:
	int operator() (int a, int b)
	{
		return a + b;
	}
};
class Plus
{
public:
	Plus(int n = 10)
		:_n(n)
	{}
	static int plusi(int a, int b)
	{
		return a + b;
	}
	double plusd(double a, double b)
	{
		return (a + b) * _n;
	}
private:
	int _n;
};
int main()
{
	// 包装各种可调⽤对象
	function<int(int, int)> f1 = f;
	function<int(int, int)> f2 = Functor();
	function<int(int, int)> f3 = [](int a, int b) {return a + b; };
	cout << f1(1, 1) << endl;
	cout << f2(1, 1) << endl;
	cout << f3(1, 1) << endl;
	// 包装静态成员函数
	// 成员函数要指定类域并且前⾯加&才能获取地址
	function<int(int, int)> f4 = &Plus::plusi;
	cout << f4(1, 1) << endl;
	// 包装普通成员函数
	// 普通成员函数还有⼀个隐含的this指针参数，所以绑定时传对象或者对象的指针过去都可以
	function<double(Plus*, double, double)> f5 = &Plus::plusd;
	Plus pd;
	cout << f5(&pd, 1.1, 1.1) << endl;
	function<double(Plus, double, double)> f6 = &Plus::plusd;
	cout << f6(pd, 1.1, 1.1) << endl;
	cout << f6(pd, 1.1, 1.1) << endl;
	function<double(Plus&&, double, double)> f7 = &Plus::plusd;
	cout << f7(move(pd), 1.1, 1.1) << endl;
	cout << f7(Plus(), 1.1, 1.1) << endl;
	return 0;
}

4.2 bind

simple(1)
template <class Fn, class... Args>
/* unspecified */ bind (Fn&& fn, Args&&... args);
with return type (2)
template <class Ret, class Fn, class... Args>
/* unspecified */ bind (Fn&& fn, Args&&... args);

• bind 是⼀个函数模板，它也是⼀个可调用对象的包装器，可以把他看做⼀个函数适配器，对接收的fn可调用对象进行处理后返回⼀个可调用对象。 bind 可以用来调整参数个数和参数顺序。bind 也在这个头文件中。
• 调用bind的⼀般形式： auto newCallable = bind(callable,arg_list); 其中newCallable本身是⼀个可调用对象，arg_list是⼀个逗号分隔的参数列表，对应给定的callable的参数。当我们调用newCallable时，newCallable会调用callable，并传给它arg_list中的参数。
• arg_list中的参数可能包含形如_n的名字，其中n是⼀个整数，这些参数是占位符，表示newCallable的参数，它们占据了传递给newCallable的参数的位置。数值n表示生成的可调用对象中参数的位置：_1为newCallable的第⼀个参数，_2为第⼆个参数，以此类推。_1/_2/_3…这些占位符放到placeholders的⼀个命名空间中。
  

后言

这就是C+11深度剖析(三)。大家自己好好消化！今天就分享到这！感谢各位的耐心垂阅！咱们下期见！拜拜~