【C++从青铜到王者】第二十二篇:C++11

矫情吗；* 2022-09-09 09:17 146阅读 0赞

![在这里插入图片描述][2e65664968f040c19ce87e1a2903e2aa.gif_pic_center]

# 系列文章目录 #

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

### 文章目录 ###

*  系列文章目录
 *  前言
 *  一、C++11简介(了解)
 *  二、 列表初始化(了解)
 *   *   *  1.C++98中\{\}的初始化问题
         *  2.内置类型的列表初始化
         *  3.自定义类型的列表初始化
 *  三、变量类型推导(了解)
 *   *   *  1.为什么需要类型推导
         *  2. decltype类型推导
         *   *  1.为什么需要decltype
             *  2. decltype
 *  四、范围for循环
 *  五、final与override
 *  六、智能指针
 *  七、新增加容器---静态数组array、forward\_list以及unordered系列
 *  八、默认成员函数控制(了解)
 *   *   *  1.显式缺省函数
         *  2.删除默认函数
 *  九、右值引用(熟悉)
 *   *   *  1.右值引用概念
         *  2.左值与右值
         *  3.引用与右值引用比较
         *  4.值的形式返回对象的缺陷
         *  5.移动语义
         *  6.右值引用引用左值
         *  7.完美转发
         *  8.右值引用作用
 *  十、 lambda表达式(熟悉)
 *   *   *  1.C++98中的一个例子
         *  2.lambda表达式
         *  3.lambda表达式用法
         *  4.函数对象与lambda表达式
 *  总结

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

# 前言 #

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

# 一、C++11简介(了解) #

在2003年C++标准委员会曾经提交了一份技术勘误表(简称TC1)，使得C++03这个名字已经取代了C++98称为C++11之前的最新C++标准名称。不过由于TC1主要是对C++98标准中的漏洞进行修复，语言的核心部分则没有改动，因此人们习惯性的把两个标准合并称为C++98/03标准。从C++0x到C++11，C++标准10年磨一剑，第二个真正意义上的标准珊珊来迟。相比于C++98/03，C++11则带来了数量可观的变化，其中包含了约140个新特性，以及对C++03标准中约600个缺陷的修正，这使得C++11更像是从C++98/03中孕育出的一种新语言。相比较而言，C++11能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全，不仅功能更强大，而且能提升程序员的开发效率。

# 二、 列表初始化(了解) #

### 1.C++98中\{\}的初始化问题 ###

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

int array1[] = { 1,2,3,4,5};
    int array2[5] = { 0};

对于一些自定义的类型，却无法使用这样的初始化。比如：

> vector v\{1,2,3,4,5\};

就无法通过编译，导致每次定义vector时，都需要先把vector定义出来，然后使用循环对其赋初始值，非常不方便。C++11扩大了用大括号括起的列表(初始化列表)的使用范围，使其可用于所有的内置类型和用户自定义的类型，使用初始化列表时，可添加等号(=)，也可不添加。

### 2.内置类型的列表初始化 ###

int main()
    { 
    	// 内置类型变量
    	int x1 = {  10 };
    	int x2{  10 };
    	int x3 = 1 + 2;
    	int x4 = {  1 + 2 };
    	int x5{  1 + 2 };
    	// 数组
    	int arr1[5] { 1, 2, 3, 4, 5};
    	int arr2[]{ 1, 2, 3, 4, 5};
    	// 动态数组，在C++98中不支持
    	int* arr3 = new int[5]{ 1, 2, 3, 4, 5};
    	// 标准容器
    	vector<int> v{  1, 2, 3, 4, 5 };
    	map<int, int> m{  {  1, 1 }, {  2, 2, }, {  3, 3 }, {  4, 4 } };
    	return 0;
    }

注意：列表初始化可以在\{\}之前使用等号，其效果与不使用=没有什么区别。

### 3.自定义类型的列表初始化 ###

标准库支持单个对象的列表初始化。

class Point
    { 
    public:
    	Point(int x = 0, int y = 0) : _x(x), _y(y)
    	{ }
    private:
    	int _x;
    	int _y;
    };
    int main()
    { 
    	Pointer p{  1, 2 };
    	return 0;
    }

**多个对象的列表初始化：**

> 多个对象想要支持列表初始化，需给该类(模板类)添加一个带有initializer\_list类型参数的构造函数即可。注意：initializer\_list是系统自定义的类模板，该类模板中主要有三个方法：begin()、end()迭代器以及获取区间中元素个数的方法size()。

#include <initializer_list>
    template<class T>
    class Vector { 
    public:
    	// ...
    	Vector(initializer_list<T> l) : _capacity(l.size()), _size(0)
    	{ 
    		_array = new T[_capacity];
    		for (auto e : l)
    			_array[_size++] = e;
    	}
    	Vector<T>& operator=(initializer_list<T> l) { 
    		delete[] _array;
    		size_t i = 0;
    		for (auto e : l)
    			_array[i++] = e;
    		return *this;
    	}
    	// ...
    private:
    	T* _array;
    	size_t _capacity;
    	size_t _size;
    };

# 三、变量类型推导(了解) #

### 1.为什么需要类型推导 ###

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16]  
**在定义变量时，必须先给出变量的实际类型，编译器才允许定义，但有些情况下可能不知道需要实际类型怎么给，或者类型写起来特别复杂，比如：**

#include <map>
    #include <string>
    int main()
    { 
    	short a = 32670;
    	short b = 32670;
    	// c如果给成short，会造成数据丢失，如果能够让编译器根据a+b的结果推导c的实际类型，就不会存在问题
    	short c = a + b;
    	std::map<std::string, std::string> m{  {  "apple", "苹果" }, {  "banana", "香蕉" } };
    	// 使用迭代器遍历容器, 迭代器类型太繁琐
    	std::map<std::string, std::string>::iterator it = m.begin();
    	while (it != m.end())
    	{ 
    		cout << it->first << " " << it->second << endl;
    		++it;
    	}
    	return 0;
    }

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 1]  
**C++11中，可以使用auto来根据变量初始化表达式类型推导变量的实际类型，可以给程序的书写提供许多方便。将程序中c与it的类型换成auto，程序可以通过编译，而且更加简洁。关于auto的详细介绍可以参考前面的博客。**

### 2. decltype类型推导 ###

#### 1.为什么需要decltype ####

**auto使用的前提是：必须要对auto声明的类型进行初始化，否则编译器无法推导出auto的实际类型。但有时候可能需要根据表达式运行完成之后结果的类型进行推导，因为编译期间，代码不会运行，此时auto也就无能为力。**

template<class T1, class T2>
    T1 Add(const T1& left, const T2& right)
    { 
       	return left + right;
    }

如果能用加完之后结果的实际类型作为函数的返回值类型就不会出错，但这需要程序运行完才能知道结果的实际类型，即RTTI(Run-Time Type Identification 运行时类型识别）。

C++98中确实已经支持RTTI：

*  typeid只能查看类型名字不能用其结果类定义类型。
 *  dynamic\_cast只能应用于含有虚函数的继承体系中。

运行时类型识别的缺陷是降低程序运行的效率。

#### 2. decltype ####

decltype是根据表达式的实际类型推演出定义变量时所用的类型，比如：

*  推演表达式类型作为变量的定义类型。

int main()
    { 
    	int a = 10;
    	int b = 20;
    	// 用decltype推演a+b的实际类型，作为定义c的类型
    	decltype(a + b) c;
    	cout << typeid(c).name() << endl;
    	return 0;
    }

*  推演函数返回值的类型：

void* GetMemory(size_t size)
    { 
    	return malloc(size);
    }
    int main()
    { 
    	// 如果没有带参数，推导函数的类型
    	cout << typeid(decltype(GetMemory)).name() << endl;
    	// 如果带参数列表，推导的是函数返回值的类型,注意：此处只是推演，不会执行函数
    	cout << typeid(decltype(GetMemory(0))).name() << endl;
    	return 0;
    }

# 四、范围for循环 #

**参考前面博客：**[C++入门][C]

# 五、final与override #

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

# 六、智能指针 #

**后续文章讲解。**

# 七、新增加容器—静态数组array、forward\_list以及unordered系列 #

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

# 八、默认成员函数控制(了解) #

在C++中对于空类编译器会生成一些默认的成员函数，比如：构造函数、拷贝构造函数、运算符重载、析构函数和&和const&的重载、移动构造、移动拷贝构造等函数。如果在类中显式定义了，编译器将不会重新生成默认版本。有时候这样的规则可能被忘记，最常见的是声明了带参数的构造函数，必要时则需要定义不带参数的版本以实例化无参的对象。而且有时编译器会生成，有时又不生成，容易造成混乱，于是C++11让程序员可以控制是否需要编译器生成。

### 1.显式缺省函数 ###

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_15_color_FFFFFF_t_70_g_se_x_16]  
在C++11中，可以在默认函数定义或者声明时加上=default，从而显式的指示编译器生成该函数的默认版本，用=default修饰的函数称为显式缺省函数。

class A
    { 
    public:
    	A(int a) : _a(a)
    	{ }
    	// 显式缺省构造函数，由编译器生成,一定生成
    	A() = default;
    	// 在类中声明，在类外定义时让编译器生成默认赋值运算符重载
    	A& operator=(const A& a);
    private:
    	int _a;
    };
    A& A::operator=(const A& a) = default;
    int main()
    { 
    	A a1(10);
    	A a2;
    	a2 = a1;
    	return 0;
    }

### 2.删除默认函数 ###

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_16_color_FFFFFF_t_70_g_se_x_16]

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

class A
    { 
    public:
    	A(int a) : _a(a)
    	{ }
    	// 禁止编译器生成默认的拷贝构造函数以及赋值运算符重载
    	A(const A&) = delete;
    	A& operator(const A&) = delete;
    private:
    	int _a;
    };
    int main()
    { 
    	A a1(10);
    	// 编译失败，因为该类没有拷贝构造函数
    	//A a2(a1);
    	// 编译失败，因为该类没有赋值运算符重载
    	A a3(20);
    	a3 = a2;
    	return 0;
    }

# 九、右值引用(熟悉) #

### 1.右值引用概念 ###

**C++98中提出了引用的概念，引用即别名，引用变量与其引用实体公共同一块内存空间，而引用的底层是通过指针来实现的，因此使用引用，可以提高程序的可读性。**

#define _CRT_SECURE_NO_WARNINGS 1
    #include<iostream>
    using namespace std;
    
    void Swap(int& left, int & right)
    { 
    	int tmp = left;
    	left = right;
    	right = tmp;
    }

**为了提高程序运行效率，C++11中引入了右值引用，右值引用也是别名，但其只能对右值引用。**

int add(int a, int b)
    { 
    	return a + b;
    }
    int main()
    { 
    	int a = 10;
    	int b = 20;
    	Swap(a, b);
    
    	const int&& ra = 10;
    
    	// 引用函数返回值，返回值是一个临时变量，为右值
    	int&& rRet = add(10, 20);
    
    	return 0;
    }

**为了与C++98中的引用进行区分，C++11将该种方式称之为右值引用。**

### 2.左值与右值 ###

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 2]  
**左值与右值是C语言中的概念，但C标准并没有给出严格的区分方式，一般认为：可以放在=左边的，或者能够取地址的称为左值，只能放在=右边的，或者不能取地址的称为右值，但是也不一定完全正确。**

#define _CRT_SECURE_NO_WARNINGS 1
    #include<iostream>
    using namespace std;
    
    int main()
    { 
    	int x = 1;
    	int y = 2;
    
    	//左值引用的定义
    	int a = 0;
    	int &b = a;
    
    	//左值引用不能引用右值，但const左值引用可以
    	//int& e = 10;
    	//int& f = x + y;
    	const int& e = 10;
    	const int& f = x + y;
    
    	//右值引用的定义
    	int&& c = 10;
    	int&& d = x + y;
    
    	//右值引用不能引用左值，但是可以引用move后左值
    	//int&& m = a;
    	int&& m = move(a);
    	
    	return 0;
    }

*  **因此关于左值与右值的区分不是很好区分，一般认为：**
 *  普通类型的变量，因为有名字，可以取地址，都认为是左值。
 *  const修饰的常量，不可修改，只读类型的，理论应该按照右值对待，但因为其可以取地址(如果只是const类型常量的定义，编译器不给其开辟空间，如果对该常量取地址时，编译器才为其开辟空间)，C++11认为其是左值。
 *  如果表达式的运行结果是一个临时变量或者对象，认为是右值。
 *  如果表达式运行结果或单个变量是一个引用则认为是左值。
 *  **总结：**
 *  不能简单地通过能否放在=左侧右侧或者取地址来判断左值或者右值，要根据表达式结果或变量的性质判断，比如上述：c常量。
 *  能得到引用的表达式一定能够作为引用，否则就用常引用。
 *  **C++11对右值进行了严格的区分：：**
 *  C语言中的纯右值，比如：a+b, 100。
 *  将亡值。比如：表达式的中间结果、函数按照值的方式进行返回。

### 3.引用与右值引用比较 ###

**在C++98中的普通引用与const引用在引用实体上的区别：**

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

**注意： 普通引用只能引用左值，不能引用右值，const引用既可引用左值，也可引用右值。**

**C++11中右值引用：只能引用右值，一般情况不能直接引用左值。**

int main()
    { 
    	// 10纯右值，本来只是一个符号，没有具体的空间，
    	// 右值引用变量r1在定义过程中，编译器产生了一个临时变量，r1实际引用的是临时变量
    	int&& r1 = 10;
    	r1 = 100;
    	int a = 10;
    	int&& r2 = a; // 编译失败：右值引用不能引用左值
    	return 0;
    }

**问题：既然C++98中的const类型引用左值和右值都可以引用，那为什么C++11还要复杂的提出右值引用呢？**

### 4.值的形式返回对象的缺陷 ###

**如果一个类中涉及到资源管理，用户必须显式提供拷贝构造、赋值运算符重载以及析构函数，否则编译器将会自动生成一个默认的，如果遇到拷贝对象或者对象之间相互赋值，就会出错，比如：**

#define _CRT_SECURE_NO_WARNINGS 1
    #include<iostream>
    #include<string>
    
    namespace yyw
    { 
    	class string
    	{ 
    		string(const char* str = "")
    		:_str(new char[strlen(str)+1])
    		{ 
    			strcpy(_str, str);
    		}
    
    		//s2(s1)
    		string(const string& s)
    			:_str(new char[strlen(s._str)+1])
    		{ 
    			strcpy(_str, s._str);
    		}
    
    		//s2=s1
    		string& operator=(const string& s)
    		{ 
    			if (this != &s)
    			{ 
    				char* _Pstr = new char[strlen(s._str) + 1];
    				strcpy(_Pstr, s._str);
    				delete[] _str;
    				_str = _Pstr;
    			}
    			return *this;
    		}
    		~string()
    		{ 
    			delete[]_str;
    			_str=nullptr;
    		}
    	private:
    		char* _str;
    	};
    }

**上述代码看起来没有什么问题，但是有一个不太尽人意的地方：**  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 3]  
在operator+中：strRet在按照值返回时，必须创建一个临时对象，临时对象创建好之后，strRet就被销毁了，最后使用返回的临时对象构造s3，s3构造好之后，临时对象就被销毁了。仔细观察会发现：strRet、临时对象、s3每个对象创建后，都有自己独立的空间，而空间中存放内容也都相同，相当于创建了三个内容完全相同的对象，对于空间是一种浪费，程序的效率也会降低，而且临时对象确实作用不是很大，那能否对该种情况进行优化呢。

### 5.移动语义 ###

**C++11提出了移动语义概念，即：将一个对象中资源移动到另一个对象中的方式，可以有效缓解该问题。**  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_19_color_FFFFFF_t_70_g_se_x_16]  
**在C++11中如果需要实现移动语义，必须使用右值引用。上述String类增加移动构造：**  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_18_color_FFFFFF_t_70_g_se_x_16]  
**因为strRet对象的生命周期在创建好临时对象后就结束了，即将亡值，C++11认为其为右值，在用strRet构造临时对象时，就会采用移动构造，即将strRet中资源转移到临时对象中。而临时对象也是右值，因此在用临时对象构造s3时，也采用移动构造，将临时对象中资源转移到s3中，整个过程，只需要创建一块堆内存即可，既省了空间，又大大提高程序运行的效率。**

**注意：**

1.  移动构造函数的参数千万不能设置成const类型的右值引用，因为资源无法转移而导致移动语义失效。
2.  在C++11中，编译器会为类默认生成一个移动构造，该移动构造为浅拷贝，因此当类中涉及到资源管理  
    时，用户必须显式定义自己的移动构造。  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 4]

### 6.右值引用引用左值 ###

按照语法，右值引用只能引用右值，但右值引用一定不能引用左值吗？因为：有些场景下，可能真的需要用右值去引用左值实现移动语义。当需要用右值引用引用一个左值时，可以通过move函数将左值转化为右值。C++11中，std::move()函数位于 头文件中，该函数名字具有迷惑性，它并不搬移任何东西，唯一的功能就是将一个左值强制转化为右值引用，然后实现移动语义。

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 5]

int main()
    { 
    	String s1("hello world");
    	String s2(move(s1));
    	String s3(s2);
    	return 0;
    }

**注意：以上代码是move函数的经典的误用，因为move将s1转化为右值后，在实现s2的拷贝时就会使用移动构造，此时s1的资源就被转移到s2中，s1就成为了无效的字符串。**  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 6]

### 7.完美转发 ###

**完美转发是指在函数模板中，完全依照模板的参数的类型，将参数传递给函数模板中调用的另外一个函数。**

### 8.右值引用作用 ###

C++98中引用作用：因为引用是一个别名，需要用指针操作的地方，可以使用指针来代替，可以提高代码的可读性以及安全性。

*  **C++11中右值引用主要有以下作用：**
 *  实现移动语义(移动构造与移动赋值)。
 *  给中间临时变量取别名。
 *  实现完美转发。  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 7]

# 十、 lambda表达式(熟悉) #

### 1.C++98中的一个例子 ###

**在C++98中，如果想要对一个数据集合中的元素进行排序，可以使用std::sort方法。**

#define _CRT_SECURE_NO_WARNINGS 1
    
    #include<iostream>
    #include<functional>
    #include<algorithm>
    
    using namespace std;
    
    template<class T>
    struct Greater
    { 
    	bool operator()(const T& x1,const T& x2)
    	{ 
    		return x1 > x2;
    	}
    };
    
    template<class T>
    bool g2(const T& x1, const T& x2)
    { 
    	return x1 > x2;
    }
    
    int main()
    { 
    	int array[] = {  4, 1, 8, 5, 3, 7, 0, 9, 2, 6 };
    	std::sort(array, array + sizeof(array) / sizeof(array[0]));
    	for (auto e : array)
    	{ 
    		cout << e << " ";
    	}
    	cout << endl;
    
    	std::sort(array, array+sizeof(array)/sizeof(array[0]),Greater<int>());
    	Greater<int> g1;
    	cout << g1(1, 2) << endl;  //g1是一个对象，这里调用的是operator()实现的比较
    	cout << g2(1, 2) << endl;  //g2是一个函数指针，这里调用他指向的函数
    	                           //两者完全不同的对象，但是他们用起来一样
    	for (auto e : array)
    	{ 
    		cout << e << " ";
    	}
    	cout << endl;
    	return 0;
    }

**如果待排序元素为自定义类型，需要用户定义排序时的比较规则：**

struct Goods
    { 
    	string _name;  //名字
    	double _price; //价格
    	int _num;      //数量
    };
    
    struct ComPriceGreater
    { 
    	bool operator()(const Goods& g1,const Goods& g2)
    	{ 
    		return g1._price > g2._price;
    	}
    };
    struct ComNumGreater
    { 
    	bool operator()(const Goods& g1, const Goods& g2)
    	{ 
    		return g1._num > g2._num;
    	}
    };
    int  main()
    { 
    	Goods goods[] = {  {  "苹果", 2.1 }, {  "相交", 3 }, {  "橙子", 2.2 }, {  "菠萝", 1.5 } };
    	std::sort(goods, goods + sizeof(goods) / sizeof(goods[0]), ComPriceGreater());
    	std::sort(goods, goods + sizeof(goods) / sizeof(goods[0]), ComNumGreater());
    	return 0;
    }

**随着C++语法的发展，人们开始觉得上面的写法太复杂了，每次为了实现一个algorithm算法， 都要重新去写一个仿函数，如果每次比较的逻辑不一样，还要去实现多个类，特别是相同类的命名，这些都给编程者带来了极大的不便。因此，在C11语法中出现了Lambda表达式。**

### 2.lambda表达式 ###

#define _CRT_SECURE_NO_WARNINGS 1
    
    #include<iostream>
    #include<functional>
    #include<algorithm>
    
    using namespace std;
    
    struct Goods
    { 
    	string _name;  //名字
    	double _price; //价格
    	int _num;      //数量
    };
    int main()
    { 
    	Goods gds[] = {  {  "苹果", 2.1 }, {  "相交", 3 }, {  "橙子", 2.2 }, {  "菠萝", 1.5 } };
    	sort(gds, gds + sizeof(gds) / sizeof(gds[0]), [](const Goods& l, const Goods& r)
    		->bool
    	{ 
    		return l._price < r._price;
    	});
    	return 0;
    }

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 8]  
**上述代码就是使用C++11中的lambda表达式来解决，可以看出lamb表达式实际是一个匿名函数。**

### 3.lambda表达式用法 ###

**lambda表达式书写格式：\[capture-list\] (parameters) mutable -> return-type \{ statement \}**

*  **lambda表达式各部分说明：**
 *  \[capture-list\] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据\[\]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。
 *  (parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略。
 *  mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)。
 *  \->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。
 *  \{statement\}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。

**注意： 在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空。因此C++11中最简单的lambda函数为：\[\]\{\}; 该lambda函数不能做任何事情。**

#define _CRT_SECURE_NO_WARNINGS 1
    
    #include<iostream>
    #include<algorithm>
    using namespace std;
    
    struct Goods
    { 
    	string _name;  //名字
    	double _price; //价格
    	int _num;      //数量
    };
    int main()
    { 
    	// 最简单的lambda表达式, 该lambda表达式没有任何意义
    	[]{ };
    
    	int a = 3;
    	int b = 4;
    	//实现a+b的lambda的表达式
    
    	auto add1 = [](int x1, int x2)->int{ return x1 + x2;};
    	cout << add1(a, b) << endl;
    
    	//直接捕捉a,b
    	//auto add2=[a,b]()->int{return a+b;};
    	auto add2 = [a, b]()->int{ return a + b; };
    	cout << add2() << endl;
    	
    	//不捕捉
    	auto swap1 = [](int& x1, int& x2)
    	{ 
    		int tmp = x1;
    		x1 = x2;
    		x2 = tmp;
    	};
    	swap1(a, b);
    	cout << a << " " << b << endl;
    	 
    	//引用捕捉
    	auto swap2 = [&]()
    	{ 
    		int tmp = a;
    		a = b;
    		b = tmp;
    	};
    	swap2();
    	cout << a << " " << b << endl;
    
    
    	Goods gds[] = {  {  "苹果", 2.1 }, {  "相交", 3 }, {  "橙子", 2.2 }, {  "菠萝", 1.5 } };
    	
    	这里会发现lamber表达式在这些地方更方便
    	std::sort(gds, gds + sizeof(gds) / sizeof(gds[0]), [](const Goods& g1, const Goods& g2)
    	{ 
    		return g1._price > g2._price;
    	});
    	std::sort(gds, gds + sizeof(gds) / sizeof(gds[0]), [](const Goods& g1, const Goods& g2)
    	{ 
    		return g1._num > g2._num;
    	});
    
    
    	return 0;
    }

**过上述例子可以看出，lambda表达式实际上可以理解为无名函数，该函数无法直接调用，如果想要直接调用，可借助auto将其赋值给一个变量。**

*  **捕获列表说明：**
 *  \[var\]：表示值传递方式捕捉变量var。
 *  \[=\]：表示值传递方式捕获所有父作用域中的变量(包括this)。
 *  \[&var\]：表示引用传递捕捉变量var。
 *  \[&\]：表示引用传递捕捉所有父作用域中的变量(包括this)。
 *  \[this\]：表示值传递方式捕捉当前的this指针。
 *  **注意：**
 *  父作用域指包含lambda函数的语句块。
 *  语法上捕捉列表可由多个捕捉项组成，并以逗号分割。
 *  比如：\[=, &a, &b\]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量 \[&，a, this\]：值传递方式捕捉变量a和this，引用方式捕捉其他变量 c. 捕捉列表不允许变量重复传递，否则就会导致编译错误。 比如：\[=, a\]：=已经以值传递方式捕捉了所有变量，捕捉a重复。
 *  在块作用域以外的lambda函数捕捉列表必须为空。
 *  在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者非局部变量都会导致编译报错。
 *  lambda表达式之间不能相互赋值，即使看起来类型相同。  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 9]

### 4.函数对象与lambda表达式 ###

**函数对象，又称为仿函数，即可以想函数一样使用的对象，就是在类中重载了operator()运算符的类对象。**  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 10]  
**实际在底层编译器对于lambda表达式的处理方式，完全就是按照函数对象仿函数的方式处理的，即：如果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator()。**

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

# 总结 #

以上就是今天要讲的内容，本文介绍了C++98上的扩展C++11，C++11提供了大量能使我们快速便捷地处理数据的函数和方法，我们务必掌握。另外如果上述有任何问题，请懂哥指教，不过没关系，主要是自己能坚持，更希望有一起学习的同学可以帮我指正，但是如果可以请温柔一点跟我讲，爱与和平是永远的主题，爱各位了。

![在这里插入图片描述][9f3b253adba24e01aa8fb3f90dbad2b4.gif_pic_center]

[2e65664968f040c19ce87e1a2903e2aa.gif_pic_center]: /images/20220829/61d9b44d36cd43598c17aa7c4ccc2555.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/ee469d903d44423a8462ecf251ca696f.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220829/6db38015cb9b49f8bea565dc41bc7d64.png
[C]: https://blog.csdn.net/qq_44918090/article/details/117163391
[bcd523b9e2da4859b306213893c0a13e.png]: /images/20220829/1081bf791898425a837839a931359a0c.png
[0fe9eab1dfac4c93b8f646b29ad8d5ce.png]: /images/20220829/7510fe03579042778953bfab84fc24fd.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_15_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/af567f7e7aa746fca80bc2090789e866.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_16_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/8bbfe181698242b099d297a15c51be31.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 2]: /images/20220829/25342b5dd4f84e098bc7c4740b3f935e.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 3]: /images/20220829/c7aa74635bdf41c6a0f7ca4eee89955c.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_19_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/545986879b7e411ca57dd1896446ec9a.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_18_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/ab884e343c2e455ea8ecd43184ee887f.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 4]: /images/20220829/613fa25d8def4a8689b728e6600c859b.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 5]: /images/20220829/a7548a95ca6545e3a213f29e57db1323.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 6]: /images/20220829/7b54d32e6d9f4837ac29334a97febef8.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 7]: /images/20220829/d76d4564cdcc40c3be7a2b67841511d2.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 8]: /images/20220829/bd99d3fdb1dc4baaabe23d08585b4faf.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 9]: /images/20220829/319d1c48051a44a6ae290baa2588f59d.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 10]: /images/20220829/f20eeca637114f72a2e402655b591193.png
[9f3b253adba24e01aa8fb3f90dbad2b4.gif_pic_center]: /images/20220829/9037899105e74316a02a5bcacf88e047.png