【C++11】C++11新特性（下）

1、类的新功能

namespace flash
{
	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;
			string tmp(s._str);
			swap(tmp);
		}
		// 赋值重载
		string& operator=(const string& s)
		{
			cout << "string& operator=(string s) -- 深拷贝" << endl;
			string tmp(s);
			swap(tmp);
			return *this;
		}
		// 移动构造
		string(string&& s)
			:_str(nullptr)
			, _size(0)
			, _capacity(0)
		{
			cout << "string(string&& s) -- 移动构造" << endl;
			swap(s);
		}
		// 移动赋值
		string& operator=(string&& s)
		{
			cout << "string& operator=(string&& s) -- 移动赋值" << endl;
			swap(s);
			return *this;
		}
        // 析构函数
		~string()
		{
			delete[] _str;
			_str = nullptr;
		}
	private:
		char* _str;
		size_t _size;
		size_t _capacity; // 不包含最后做标识的\0
	};
}

默认成员函数

原来C++类中（C++11之前），有6个默认成员函数：

1. 构造函数。
2. 析构函数。
3. 拷贝构造函数。
4. 拷贝赋值重载。
5. 取地址重载。
6. const 取地址重载。

最重要的是前4个，后两个用处不大。默认成员函数就是我们不写编译器会生成一个默认的。C++11 新增了两个：移动构造函数和移动赋值运算符重载。针对移动构造和移动赋值，编译器也会默认生成，不过生成的条件极其苛刻，下面展开来讨论：

• 移动构造：

  • 如果你没有自己实现移动构造函数，且均没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。

• 移动赋值：

  • 如果你没有自己实现移动赋值重载函数，且均没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个，那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造完全类似)

• 总结：

  • 如果你提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值。

• 示例：

  • 对于如下的Person类，我们不需要写析构、拷贝构造、赋值重载，因为Person的成员变量_name是自定义类型，会自动去调用string类的拷贝构造、析构、赋值重载完成深拷贝。而内置类型_age完成值拷贝即可。

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:
	cpp::string _name;
	int _age;
};
int main()
{
	Person s1;
	Person s2 = s1;//拷贝构造
	Person s3 = std::move(s1);//移动构造
	Person s4;
	s4 = std::move(s2);//移动赋值
	return 0;
}

因为我们都没写拷贝构造、析构、赋值，所以编译器会默认生成移动构造和移动赋值运算符重载。针对main函数的测试用例，很明显，s2 = s1是拷贝构造，下面的两个分别调用移动构造和移动赋值：

但凡我把Person类中的任何一个拷贝构造或析构或赋值放出来，结果都是去调用string类的拷贝构造函数去完成深拷贝：

类成员变量初始化

默认生成的构造函数，对于自定义类型会自动调用它的构造函数进行初始化，对于内置类型并不会进行处理，于是C++11允许在类定义时给成员变量初始缺省值，默认生成构造函数会使用这些缺省值初始化。

class Person
{
public:
	//……
private:
	//C++11允许非静态成员变量在声明时进行初始化赋值
	flash::string _name = "王五";
	int _age = 19;
	static int _num;//静态成员变量不能给缺省值
};

强制生成默认函数的关键字default

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

示例：如下我们实现了拷贝构造，所以编译器就不会生成移动构造和移动赋值了，会去调用自定义类型string类的拷贝构造函数完成深拷贝：

class Person
{
public:
	//构造函数
	Person(const char* name = "", int age = 0)
		:_name(name)
		, _age(age)
	{}
	//拷贝构造
	Person(const Person& p)
		:_name(p._name)
		, _age(p._age)
	{}
private:
	flash::string _name;
	int _age;
};
int main()
{
	Person s1;
	Person s2 = s1;
	Person s3 = std::move(s1);
	Person s4;
	s4 = std::move(s2);
	return 0;
}

为了让编译器生成移动构造和移动赋值，我们可以使用default关键字显示指定生成移动构造或移动赋值：

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(Person&& pp) = default;
	//强制生成移动赋值
	Person& operator=(Person&& pp) = default;
private:
	flash::string _name;
	int _age;
};

禁止生成默认函数的关键字delete

在C++中，如果想禁止生成默认成员函数，我们有如下两种方式：

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

示例：我不想让一个类被拷贝，那么在拷贝构造声明的后面加上=delete即可：

继承和多态中的final与override关键字

final：修饰虚函数，表示该虚函数不能再被重写，修饰类表示不能被继承。

这里我父类的虚函数Drive不想被其它人重写，在其后面加上final即可，此时子类就无法对Drive进行重写了，如下：

final修饰一个类，让其不能被继承，如下：

override：override的作用是检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。

2、可变参数模板

可变参数模板的概念

C++11的新特性可变参数模板能够让您创建可以接受可变参数的函数模板和类模板，相比C++98/03，类模版和函数模版中只能含固定数量的模版参数，可变模版参数无疑是一个巨大的改进。然而由于可变模版参数比较抽象，使用起来需要一定的技巧，所以这块还是比较晦涩的。现阶段呢，我们掌握一些基础的可变参数模板特性就够我们用了，所以这里我们点到为止。

下面就是一个基本可变参数的函数模板：

// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template <class ...Args>
void ShowList(Args... args)
{}

上面的参数args前面有省略号，所以它就是一个可变模版参数，我们把带省略号的参数称为“参数包”，它里面包含了0到N（N>=0）个模版参数。

模板参数包Args和函数形参参数包args的名称可以自己进指定。

现在调用ShowList函数就可以传入任意个数的任意类型的参数了：

int main()
{
	ShowList(1, 'x', 2.2, "abc");
	ShowList(-1, -2, -3);
	return 0;
}

我们也可以通过sizeof获得参数包的个数，但注意格式：sizeof…(args)

template <class ...Args>
void ShowList(Args... args)
{
	cout << sizeof...(args) << endl;//获取参数包中参数的个数
}

我们无法直接获取参数包args中的每个参数的，只能通过展开参数包的方式来获取参数包中的每个参数，这是使用可变模版参数的一个主要特点，也是最大的难点，即如何展开可变模版参数。语法并不支持使用args[i]这样方式获取可变参数。也不支持auto范围for的方式获取可变参数：

template <class ...Args>
void ShowList(Args... args)
{
	/*不支持args[i]
	for (size_t i = 0; i < sizeof...(args); ++i)
	{
		cout << args[i] << endl;
	}*/
	/*不支持auto范围for
	for (auto& e : args)
	{
		cout << e << endl;
	}*/
}

由于语法不支持使用args[i]这样方式获取可变参数，所以我们的用一些奇招来一一获取参数包的值。

参数包的展开方式

递归函数方式展开参数包

递归展开参数包需要实现两个函数，且二者同名：

• 递归函数
• 递归终止函数

我们分开来讨论：

递归函数：

• 给可变参数的函数模板增加一个模板参数，用于后续获得每一个参数的值。
• 在该函数模板中递归调用函数模板，把剩下的参数包传进去。
• 一直递归下去，每次分离参数包中的一个参数，直至全部分离出来。

//递归函数
template <class T, class ...Args>
void ShowList(const T& val, Args... args)
{
	cout << sizeof...(args) << endl;//获取参数包中参数的个数
	cout << val << "->" << typeid(val).name() << endl;
	ShowList(args...);
}

递归终止函数：

这里我们也给出两个终止函数的方式：

• 带参的终止函数
• 无参的终止函数

先看带参的终止函数，结合递归函数和测试用例一起看：

//带参的终止函数
template <class T>
void ShowList(const T& val)
{
	cout << val << "->" << typeid(val).name() << " end" << endl;
}

根据参数的最匹配原则，当参数包只有一个参数的时候，编译器会优先匹配到此终止函数完成递归终止。接下来把整体的代码加上测试用例一起看：

//带参的终止函数
template <class T>
void ShowList(const T& val)
{
	cout << val << "->" << typeid(val).name() << " end" << endl;
}
//递归函数
template <class T, class ...Args>
void ShowList(const T& val, Args... args)
{
	cout << sizeof...(args) << endl;//获取参数包中参数的个数
	cout << val << "->" << typeid(val).name() << endl;
	ShowList(args...);
}
int main()
{
	ShowList(1, 'x', 1.1);
	return 0;
}

首先，1传给val，把x和1.1传给参数包，推出T的类型为int，参数包的个数为2，打印后，继续递归把x传给val，把1.1传给参数包，推出T的类型为char，参数表的个数为1，打印后再继续递归，此时参数包的个数只有一个，根据模板的最匹配原则，这一个参数会匹配到递归终止函数。

但该方法有一个弊端就是，我们在调用ShowList函数时必须至少传入一个参数，否则就会报错。因为此时无论是调用递归终止函数还是展开函数，都需要至少传入一个参数。

下面来看看无参的递归终止函数：

//无参的终止函数
void ShowList()
{}

此时当参数包的个数为0个的时候，就会走此函数，完成递归终止。

• 如果外部调用ShowList函数时就没有传入参数，那么就会直接匹配到无参的递归终止函数。
• 而我们本意是想让外部调用ShowList函数时匹配的都是函数模板，并不是让外部调用时直接匹配到这个递归终止函数。

//无参的终止函数
void ShowList()
{}
//递归函数
template <class T, class ...Args>
void ShowList(const T& val, Args... args)
{
	cout << sizeof...(args) << endl;//获取参数包中参数的个数
	cout << val << "->" << typeid(val).name() << endl;
	ShowList(args...);
}
int main()
{
	ShowList(1, 'x', 1.1);
	cout << endl;
	ShowList(1, 2, 3, 4, 5);
	cout << endl;
	ShowList();
	return 0;
}

值得注意的是递归终止的方式不能按照如下的方式写：

//递归函数
template <class T, class ...Args>
void ShowList(const T& val, Args... args)
{
	//错误的写法：
	if (sizeof...(args) == 0)
	{
		return;
	}
	cout << val << "->" << typeid(val).name() << endl;
	ShowList(args...);
}

• 函数模板并不能调用，函数模板需要在编译时根据传入的实参类型进行推演，生成对应的函数，这个生成的函数才能够被调用。
• 而这个推演过程是在编译时进行的，当推演到参数包args中参数个数为0时，还需要将当前函数推演完毕，这时就会继续推演传入0个参数时的ShowList函数，此时就会产生报错，因为ShowList函数要求至少传入一个参数。
• 这里编写的if判断是在代码编译结束后，运行代码时才会所走的逻辑，也就是运行时逻辑，而函数模板的推演是一个编译时逻辑。

逗号表达式展开参数包

先给出使用逗号表达式展开参数包的一个例子：

template <class T>
void PrintArg(const T& t)
{
	cout << t << " ";
}
template <class ...Args>
void ShowList(Args... args)
{
	//列表初始化+逗号表达式
	int arr[] = { (PrintArg(args), 0)... };
	cout << endl;
}
int main()
{
	ShowList(1, 'x', 1.1, string("hello world"));
	ShowList(1, 2, 3, 4, 5);
	return 0;
}

下面我将给出其演化的过程，前面我们学习到了可以使用{ }列表初始化来初始化数组等内置类型和自定义类型，那么就可以试试直接把参数包放到列表初始化：

template <class ...Args>
void ShowList(Args... args)
{
	//列表初始化
	int arr[] = { args... };
	cout << endl;
}

这里很明显是不可以的，C++只允许数组里面是同一种类型，但是模板的可变参数就意味着我参数包的类型并不统一，会出现一会是int，一会是char……。为了解决此问题，我们可以单独封装一层函数（PrintArg），此函数专门用于获得参数包的每个数据并输出，但是这又会出现一个问题，我得不到一个返回值放回数组里头，为了解决返回值的问题，又使用了逗号表达式来解决：

• 逗号表达式会从左到右依次计算各个表达式，并且将最后一个表达式的值作为返回值进行返回。
• 将逗号表达式的最后一个表达式设置为一个整型值，确保逗号表达式返回的是一个整型值。
• 将处理参数包中参数的动作封装成一个函数，将该函数的调用作为逗号表达式的第一个表达式。

这里我们把逗号表达式的最后一个值设为0，此时我参数包里有几个参数，那么就有几个0，也就代表有几个值。调整后的代码如下：

template <class T>
void PrintArg(const T& t)
{
	cout << t << " ";
}
template <class ...Args>
void ShowList(Args... args)
{
	//列表初始化+逗号表达式
	int arr[] = { (PrintArg(args), 0)... };
	cout << endl;
}

可变参数的省略号需要加在逗号表达式外面，表示需要将逗号表达式展开，如果将省略号加在args的后面，那么参数包将会被展开后全部传入PrintArg函数，代码中的{(PrintArg(args), 0)…}将会展开成{(PrintArg(arg1), 0), (PrintArg(arg2), 0), (PrintArg(arg3), 0), etc…}。

此时我们就会发现，就和一开始我们给出的代码一致了，这就是是用来逗号表达式的方式展开参数包。下面给出测试用例：

int main()
{
	ShowList(1, 'x', 1.1, string("hello world"));
	ShowList(1, 2, 3, 4, 5);
	return 0;
}

当然，这里其实不用逗号表达式也可以，直接给PrintArg函数带上返回值即可完成逗号表达式的功能：

template <class T>
int PrintArg(const T& t)
{
	cout << t << " ";
	return 0;
}
template <class ...Args>
void ShowList(Args... args)
{
	//列表初始化
	int arr[] = { PrintArg(args)... };
	cout << endl;
}

此时可以传入多种类型的参数了，但是不能不传参数，因为数组的大小不能为0，为了支持不传参数，我们需要单独写个无参的ShowList函数，就像无参版的终止函数那样：

//支持无参调用
void ShowList()
{
	cout << endl;
}
template <class T>
int PrintArg(const T& t)
{
	cout << t << " ";
	return 0;
}
template <class ...Args>
void ShowList(Args... args)
{
	//列表初始化
	int arr[] = { PrintArg(args)... };
	cout << endl;
}

总结：

• 这种展开参数包的方式，不需要通过递归终止函数，是直接在expand函数体中展开的, Printarg不是一个递归终止函数，只是一个处理参数包中每一个参数的函数。这种就地展开参数包的方式实现的关键是逗号表达式。我们知道逗号表达式会按顺序执行逗号前面的表达式。
• expand函数中的逗号表达式：(printarg(args), 0)，也是按照这个执行顺序，先执行printarg(args)，再得到逗号表达式的结果0。同时还用到了C++11的另外一个特性——初始化列表，通过初始化列表来初始化一个变长数组, {(printarg(args), 0)…}将会展开成((printarg(arg1),0),(printarg(arg2),0),(printarg(arg3),0), etc… )，最终会创建一个元素值都为0的数组int arr[sizeof…(Args)]。由于是逗号表达式，在创建数组的过程中会先执行逗号表达式前面的部分printarg(args)打印出参数，也就是说在构造int数组的过程中就将参数包展开了，这个数组的目的纯粹是为了在数组构造的过程展开参数包。

STL容器中的empalce相关接口函数

template <class... Args>
void emplace_back (Args&&... args);

首先我们看到的emplace系列的接口，支持模板的可变参数，并且万能引用。那么相对insert和emplace系列接口的优势到底在哪里呢？

int main()
{
	std::list< std::pair<int, char> > mylist;
	// emplace_back支持可变参数，拿到构建pair对象的参数后自己去创建对象
	// 那么在这里我们可以看到除了用法上，和push_back没什么太大的区别
	mylist.emplace_back(10, 'a');
	mylist.emplace_back(20, 'b');
	mylist.emplace_back(make_pair(30, 'c'));
	mylist.push_back(make_pair(40, 'd'));
	mylist.push_back({ 50, 'e' });
	for (auto e : mylist)
		cout << e.first << ":" << e.second << endl;
	return 0;
}

int main()
{
	// 下面我们试一下带有拷贝构造和移动构造的bit::string，再试试呢
	// 我们会发现其实差别也不到，emplace_back是直接构造了，push_back
	// 是先构造，再移动构造，其实也还好。
	std::list< std::pair<int, cpp::string> > mylist;
	mylist.emplace_back(10, "sort");
	mylist.emplace_back(make_pair(20, "sort"));
	mylist.push_back(make_pair(30, "sort"));
	mylist.push_back({ 40, "sort" });
	return 0;
}

总结：

• emplace系列接口最大的特点就是支持传入参数包，用这些参数包直接构造出对象，这样就能减少一次拷贝，这就是为什么有人说emplace系列接口更高效的原因。
• 但emplace系列接口并不是在所有场景下都比原有的插入接口高效，如果传入的是左值对象或右值对象，那么emplace系列接口的效率其实和原有的插入接口的效率是一样的。
• emplace系列接口真正高效的情况是传入参数包的时候，直接通过参数包构造出对象，避免了中途的一次拷贝。

3、lambda表达式

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

#include <algorithm>
#include <functional>
int main()
{
	int array[] = { 4,1,8,5,3,7,0,9,2,6 };
	// 默认按照小于比较，排出来结果是升序
	std::sort(array, array + sizeof(array) / sizeof(array[0]));
	// 如果需要降序，需要改变元素的比较规则
	std::sort(array, array + sizeof(array) / sizeof(array[0]), greater<int>());
	return 0;
}

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

struct Goods
{
	string _name; // 名字
	double _price; // 价格
	int _evaluate; // 评价
};

这里想要对商品排序，可以采用sort函数，对于sort函数则有仿函数和重载( )运算符这两种方法：

• 对于此自定义类型，不可采用重载( )运算符的方法，因为( )运算符只能针对其中一种方法进行排序，比如名字或加个或评价，如果我对名字进行排序了，但是后续想要通过对价格进行排序，此时就行不通了，就需要再改重载( )的方法，这么做实在是太麻烦了，不适合用。
• 相反，按照我们先前学过的知识点，使用仿函数可以很好的进行任意一种方式的排序（名字、价格、评价），实现如下：

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 } };
	sort(v.begin(), v.end(), ComparePriceLess());//按价格升序排
	sort(v.begin(), v.end(), ComparePriceGreater());//按价格降序排
}

使用仿函数可以解决此问题，不过比较麻烦，如果我自定义类型有10个变量，恰好我又对这些变量有排序的需求，那么我就要写20个仿函数，代价稍微有点大。

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

这里我们先给出使用lambda表达式的方法解决上述对于自定义类型的排序需求的问题：

int main()
{
	vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,
	3 }, { "菠萝", 1.5, 4 } };
	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; });
}

上述代码就是使用C++11中的lambda表达式来解决，可以看出lambda表达式实际是一个匿名函数。下面我将演示lambda究竟是什么，以及其如何演化到上面的代码的。

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函数不能做任何事情。

比如我要实现Add加法函数：

int main()
{
	int a = 2, b = 5;
	auto Add1 = [](int x, int y)->int { return x + y; };
	cout << Add1(a, b) << endl;//7
	return 0;
}

返回值类型明确的情况下，返回值类型可以省略掉，由编译器自动推导：

int main()
{
	int a = 2, b = 5;
	//返回值类型明确的情况下，返回值类型可以省略掉，由编译器自动推导
	auto Add2 = [](int x, int y) { return x + y; };
	cout << Add2(a, b) << endl;//7
	return 0;
}

来看下指定返回值类型的情况：

int main()
{
	int a = 0, b = 200;
	auto Add1 = [](int x, int y)->double { return (x + y) / 3.0; };
	auto Add2 = [](int x, int y)->int { return (x + y) / 3.0; };
	cout << Add1(a, b) << endl;//66.6667
	cout << Add2(a, b) << endl;//66
	return 0;
}

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

lambda表达式捕捉列表说明

捕捉列表描述了上下文中那些数据可以被lambda使用，以及使用的方式传值还是传引用。

• [var]：表示值传递方式捕捉变量var。
• [=]：表示值传递方式捕获所有父作用域中的变量(包括this)。
• [&var]：表示引用传递捕捉变量var。
• [&]：表示引用传递捕捉所有父作用域中的变量(包括this)。
• [this]：表示值传递方式捕捉当前的this指针。

注意：

• 父作用域指包含lambda函数的语句块。
• 语法上捕捉列表可由多个捕捉项组成，并以逗号分割。比如：[=, &a, &b]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量。[&，a, this]：值传递方式捕捉变量a和this，引用方式捕捉其他变量。
• 捕捉列表不允许变量重复传递，否则就会导致编译错误。比如：[=, a]：=已经以值传递方式捕捉了所有变量，捕捉a重复。
• 在块作用域以外的lambda函数捕捉列表必须为空。
• 在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者非局部变量都会导致编译报错。
• lambda表达式之间不能相互赋值，即使看起来类型相同。

对于上述实现的Add加法函数，如果我不想传参数，那么就需要用到捕捉列表。此时参数和返回值均可省略，且调用的地方也不需要传参：

int main()
{
	int a = 0, b = 200;
	auto Add1 = [](int x, int y)->int { return (x + y) / 3.0; };
	cout << Add1(a, b) << endl;//66
	//传值捕捉
	auto Add2 = [a, b] { return (a + b) / 3.0; };
	cout << Add2() << endl;//66.6667
	return 0;
}

如果交换函数不需要用到返回值，所以返回值可以省略，其次注意形参的改变不会影响实参，需要传引用：

int main()
{
	int a = 0, b = 200;
	auto swap1 = [](int& x, int& y) {
		int tmp = x;
		x = y;
		y = tmp;
	};
	swap1(a, b);
	cout << a << " " << b << endl;//200 0
	return 0;
}

假设我不想用用到参数列表，那么就需要在捕获列表进行捕捉：

注意这样写会出现一个问题， 默认情况下，lambda函数总是一个const函数，所以a和b不可被修改，我们可以使用mutable来取消其常量性。

此时又会出现一个问题，怎么我又交换不了了，原因还是形参的改变不会印象实参，捕获列表要引用传递捕获变量：

int main()
{
	int a = 0, b = 200;
	auto swap2 = [&a, &b] {
		int tmp = a;
		a = b;
		b = tmp;
	};
	swap2();
	cout << a << " " << b << endl;//200 0
	return 0;
}

=和&的好处在于，当我需要获得多个变量时，可以直接采用=或&捕获所有父作用域变量：

int main()
{
	int c = 2, d = 3, e = 4, f = 5, g = 6, ret;
	//传值捕获全部变量
	auto Func1 = [=] {
		return c + d * e / f + g - 1;
	};
	cout << Func1() << endl;//9
	//传引用捕获全部变量
	auto Func2 = [&] {
		ret = c + d * e / f + g - 2;
		return ret;
	};
	cout << Func2() << endl;//8
	//混着捕捉：c,d传值。ret传引用
	auto Func3 = [c, d, &ret] {
		ret = c + d;
		return ret;
	};
	cout << Func3() << endl;//5
	//混着捕捉：ret传引用捕捉，其它全部传值捕捉
	auto Func4 = [=, &ret] {
		ret = c + d * e / f + g - 3;
		return ret;
	};
	cout << Func4() << endl;//7
	return 0;
}

lambda表达式之间不能相互赋值，即使看起来类型相同。

void (*PF)();
int main()
{
	auto f1 = [] {cout << "hello world" << endl; };
	auto f2 = [] {cout << "hello world" << endl; };
	// 此处先不解释原因，等lambda表达式底层实现原理看完后，大家就清楚了
	//f1 = f2; // 编译失败--->提示找不到operator=()
	// 允许使用一个lambda表达式拷贝构造一个新的副本
	auto f3(f2);
	f3();
	// 可以将lambda表达式赋值给相同类型的函数指针
	PF = f2;
	PF();
	return 0;
}

使用lambda表达式排序自定义类型

说完了lambda的基础语法，再来看看我们一开始引入lambda时写的自定义类型：

struct Goods
{
	string _name; // 名字
	double _price; // 价格
	int _evaluate; // 评价
};

先前我们说对此自定义类型可以采用仿函数的方式进行排序，不过代码量繁杂，我们可以使用lambda来解决：

int main()
{
	vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,3 }, { "菠萝", 1.5, 4 } };
	auto priceLess = [](const Goods& g1, const Goods& g2) {return g1._price < g2._price; };
	sort(v.begin(), v.end(), priceLess);
}

不过我们这里写的还算“保守”，因为我还给lambda表达式的返回值取名了，我们可以直接把它当成返回值放入sort函数里头，这里再演示其它变量用lambda排序的方式：

struct Goods
{
	string _name; // 名字
	double _price; // 价格
	int _evaluate; // 评价
};
int main()
{
	vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,3 }, { "菠萝", 1.5, 4 } };
	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; });//评分降序
}

此时就和我们前面给出的lambda表达式解决自定义类型排序的写法一致啦，这就是整个推演过程。

关于lambda是否可以取代仿函数这个问题问题，我认为是不可以的，通过我们上面的学习，发现lambda对处理自定义类型的排序确实要方便很多，不过在模板参数中不能使用lambda表达式，只能使用仿函数，原因如下：

• 仿函数既可以代表类型，也可以代表对象。
• lambda定义的是一个对象。

而我模板参数的需求是要传类型，这里很显然就只能使用仿函数了。

lambda表达式的底层原理

实际上lambda的底层就是仿函数，函数对象，又称为仿函数，即可以像函数一样使用的对象，就是在类中重载了operator()运算符的类对象。

如下我下了一个Rate求利率的仿函数，里面对( )运算符进行了重载，因此Rate实例化出的r1对象即函数对象，使r1可以像函数一样使用，后续又编写了一个lambda表达式，借助auto将其赋值给r2对象，使其也能够像函数一样使用。

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;
	Rate r1(rate);
	r1(10000, 2);
	// lambda表达式
	auto r2 = [=](double monty, int year)->double {return monty * rate * year; };
	r2(10000, 2);
	return 0;
}

下面调试代码进入反汇编，看到如下现象：

普通仿函数：

• 创建函数对象r1时，调用Rate类的构造函数。
• 调用函数对象r1时，调用Rate类的( )运算符重载。

lambda表达式：

• 借助auto把lambda表达式赋值给r2时，会调用<lambda_uuid>类的构造函数。
• 在调用r2对象时，会调用<lambda_uuid>类的()运算符重载函数。

我定义一个lambda表达式，那么底层会生成一个仿函数，编译器看不到lambda，看到的是这个仿函数，当我调用lambda表达式的时候，编译器回去调用此仿函数的operator( )运算符重载。

至于<lambda_2……330b3>这么一长串东西就是我们图示标注的<lambda_uuid>，也就是仿函数的类型名称。

类名中的uuid：

• 类名中的uuid是通用唯一识别码（Universally Unique Identifier）的缩写，其作用是通过算法生成一些唯一的字符串，保证在当前程序当中每次生成的uuid都不会重复。
• 上层是看不到lambda的名称的，所以这就导致给lambda取名字时很容易就会冲突，使用了uuid，那么不同的lambda转换后生成仿函数的名称就不一样了，也就不会发生冲突了。

lambda表达式之间不能相互赋值：

• 对于我们先前给出的示例，即使我两个lambda表达式的实现是一样的，但lambda表达式在底层会被处理为函数对象，该函数对象对应的类名叫做<lambda_uuid>，uuid通过算法生成一串字符串，保证在当前程序当中每次生成的uuid都不会重复。这里也就生成了两个类型的仿函数，自然也就是两个不同的对象，当然就不能赋值。

void (*PF)();
int main()
{
	auto f1 = [] {cout << "hello world" << endl; };
	auto f2 = [] {cout << "hello world" << endl; };
	//f1 = f2; // 编译失败--->提示找不到operator=()
	// 允许使用一个lambda表达式拷贝构造一个新的副本
	auto f3(f2);
	f3();
	// 可以将lambda表达式赋值给相同类型的函数指针
	PF = f2;
	PF();
	return 0;
}

综上所述：

• 每个lambda都会被转换成一个仿函数类型。
• 普通仿函数的名称是自己取的，lambda的仿函数名称是编译器取的。

4、包装器

function包装器

来看这样一行代码：

ret = func(x);

上面func可能是什么呢？那么func可能是函数名？函数指针？函数对象(仿函数对象)？也有可能是lamber表达式对象？所以这些都是可调用的类型！如此丰富的类型，可能会导致模板的效率低下！为什么呢？我们继续往下看：

template<class F, class T>
T useF(F f, T x)
{
	static int count = 0;
	cout << "count:" << ++count << endl;
	cout << "count:" << &count << endl;
	return f(x);
}
double f(double i)
{
	return i / 2;
}
struct Functor
{
	double operator()(double d)
	{
		return d / 3;
	}
};
int main()
{
	// 函数名
	cout << useF(f, 11.11) << endl;
	// 函数对象
	cout << useF(Functor(), 11.11) << endl;
	// lambda表达式
	cout << useF([](double d)->double { return d / 4; }, 11.11) << endl;
	return 0;
}

通过上面的程序验证，我们会发现useF函数模板实例化了三份。每份count的地址都是不一样的。有没有办法让useF函数模板只实例化一份呢？为了让可调用的类型统一起来，C++11引入了function包装器来解决。

function包装器的概念

unction包装器也叫作适配器。C++中的function本质是一个类模板，也是一个包装器，function类模板的原型如下：

std::function在头文件<functional>
// 类模板原型如下
template <class T> function; // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;
模板参数说明：
Ret : 被调用函数的返回类型
Args…：被调用函数的形参

有了function包装器，就可以对可调用对象进行包装，包括函数指针（函数名）、仿函数（函数对象）、lambda表达式、类的成员函数。示例：

#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:
	static int plusi(int a, int b)
	{
		return a + b;
	}
	double plusd(double a, double b)
	{
		return a + b;
	}
};
int main()
{
	// 函数名(函数指针)
	std::function<int(int, int)> func1 = f;
	cout << func1(1, 2) << endl;//3
	// 仿函数
	std::function<int(int, int)> func2 = Functor();
	cout << func2(10, 20) << endl;//30
	// lambda表达式
	std::function<int(int, int)> func3 = [](int a, int b) {return a + b; };
	cout << func3(15, 25) << endl;//40
	//类的静态成员函数
	std::function<int(int, int)> func4 = Plus::plusi;//非静态成员函数必须加&，静态可不加
	cout << func4(100, 200) << endl;//300
	//类的非静态成员函数
	std::function<double(Plus, double, double)> func5 = &Plus::plusd;//非静态成员函数必须加&，静态可不加
	cout << func5(Plus(), 100.11, 200.11) << endl;//300.22
	return 0;
}

注意：

• 类的成员函数在包装的时候记得指定类域。
• 类的非静态成员函数必须加&，静态成员函数可加可不加。
• 类的非静态成员函数存在隐含的this指针，包装的时候要多增加一个参数（类名），调用的时候多传一个类的匿名对象。

使用function包装器优化逆波兰表达式求值

解决此题的步骤如下：

• 定义一个栈，遍历此数组。
• 遍历到数字直接push入栈。
• 若遍历到的字符串不是数字（“+”、“-”、“*”、"/"其中任意一个字符串），取栈顶的两个元素进行对应的算数运算，并把结果再push入栈。
• 遍历结束，最终栈顶的元素就是最终的值。

代码如下：

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> st;
        for (int i = 0; i < tokens.size(); i++)
        {
            if (!(tokens[i] == "+" || tokens[i] == "-" || tokens[i] == "*" || tokens[i] == "/"))
            {
                st.push(stoi(tokens[i]));
            }
            else
            {
                int num1 = st.top();
                st.pop();
                int num2 = st.top();
                st.pop();
                if (tokens[i] == "+")
                    st.push(num1 + num2);
                else if (tokens[i] == "-")
                    st.push(num2 - num1);
                else if (tokens[i] == "*")
                    st.push((long)num1 * num2);
                else if (tokens[i] == "/")
                    st.push(num2 / num1);
            }
        }
        return st.top();
    }
};

上述代码中，我主要是通过if、else语句来判断其进行何种运算，若后续运算类型增加了，那么还要增加if、else语句，多少有点冗余，我们可以使用包装器来优化此代码。

优化规则如下：

• 这里我们可以利用包装器建立操作符和对应函数的映射关系，这一步需要用到map容器，在列表初始化里头对每个操作符完成对应的函数映射关系。
• 遍历数组，判断字符是否在map容器里头，如果在，说明是操作符，取栈顶的两个元素，进行相应的运算后，把结果push到栈里。
• 若字符不在map容器里头，说明是操作数，直接入栈。
• 遍历结束，最后直接返回栈顶的元素。
• 注意要防止栈溢出，要用long long的类型。

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<long long> st;
        map<string, function<long long(long long, long long)>> opFuncMap = 
        {
            {"+", [](long long x, long long y){return x + y;}},
            {"-", [](long long x, long long y){return x - y;}},
            {"*", [](long long x, long long y){return x * y;}},
            {"/", [](long long x, long long y){return x / y;}}
        };
        for (auto& str : tokens)
        {
            if (opFuncMap.count(str))//判断操作符是否在opFuncMap
            {
                long long right = st.top();
                st.pop();
                long long left = st.top();
                st.pop();
                st.push(opFuncMap[str](left, right));
            }
            else//操作数
            {
                st.push(stoi(str));
            }
        }
        return st.top();
    }
};

使用function包装器解决模板效率地下，实例化多份的问题

在一开始我们引入包装器时，提出了传不同的类型，要实例化三份，导致模板效率低下，现在我不再传直接函数指针、lambda……了，相反用包装器将其包装起来就解决此问题了：

#include <functional>
template<class F, class T>
T useF(F f, T x)
{
	static int count = 0;
	cout << "count:" << ++count << endl;
	cout << "count:" << &count << endl;
	return f(x);
}
double f(double i)
{
	return i / 2;
}
struct Functor
{
	double operator()(double d)
	{
		return d / 3;
	}
};
int main()
{
	// 函数名
	std::function<double(double)> func1 = f;
	cout << useF(func1, 11.11) << endl;
	// 函数对象
	std::function<double(double)> func2 = Functor();
	cout << useF(func2, 11.11) << endl;
	// lamber表达式
	std::function<double(double)> func3 = [](double d)->double { return d / 4; };
	cout << useF(func3, 11.11) << endl;
	return 0;
}

此时会发现只实例化了一份，count的地址始终是一样的，所以静态成员变量自然在累加。由此可见，包装器统一了类型。

function包装器的意义

• 将可调用对象的类型进行统一，便于我们对其进行统一化管理。
• 包装后明确了可调用对象的返回值和形参类型，更加方便使用者使用。

bind包装器

#include<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 x = 2)
		:_x(x)
	{}
	int plusi(int a, int b)
	{
		return (a + b) * _x;
	}
private:
	int _x;
};

非静态成员函数是有隐含的this指针的，所以在包装plusi函数的时候得多传一个参数（共3个），这是我们前面讲过的，而Functor和f仅需传2个参数即可：

int main()
{
	// 函数名(函数指针)
	std::function<int(int, int)> func1 = f;
	cout << func1(1, 2) << endl;//3
	// 仿函数
	std::function<int(int, int)> func2 = Functor();
	cout << func2(10, 20) << endl;//30
	//类的非静态成员函数
	std::function<double(Plus, int, int)> func3 = &Plus::plusi;//非静态成员函数必须加&，静态可不加
	cout << func3(Plus(), 100, 200) << endl;//300.22
}

假设我现在利用包装器建立字符串和对应函数的映射关系，并放到map容器里头，此时就会出现问题了：成员函数会有三个参数，而我map容器里的value位置仅允许传两个参数，导致参数无法匹配：

为了解决此问题，就需要用到我们下面的bind包装器。

bind包装器的概念

std::bind函数定义在头文件中，是一个函数模板，它就像一个函数包装器(适配器)，接受一个可调用对象（callable object），生成一个新的可调用对象来“适应”原对象的参数列表。一般而言，我们用它可以把一个原本接收N个参数的函数fn，通过绑定一些参数，返回一个接收M个（M可以大于N，但这么做没什么意义）参数的新函数。同时，使用std::bind函数还可以实现参数顺序和个数调整等操作。bind函数模板原型如下：

template <class Fn, class... Args>
/* unspecified */ bind(Fn&& fn, Args&&... args);
template <class Ret, class Fn, class... Args>
/* unspecified */ bind(Fn&& fn, Args&&... args);

模板参数说明：

• fn：可调用对象
• args…：要绑定的参数列表（值或占位符）

调用bind的一般形式：

auto newCallable = bind(callable,arg_list);

解释说明：

• callable：需要包装的可调用对象。
• newCallable：本身是一个可调用对象
• arg_list：是一个逗号分隔的参数列表，对应给定的callable的参数。当我们调用newCallable时，newCallable会调用callable，并传给它arg_list中的参数。

arg_list中的参数可能包含形如_n的名字，其中n是一个整数，这些参数是“占位符”，表示newCallable的参数，它们占据了传递给newCallable的参数的“位置”。数值n表示生成的可调用对象中参数的位置：_1为newCallable的第一个参数，_2为第二个参数，以此类推。

bind包装器绑定调整参数个数

绑定普通函数：

int Plus(int a, int b)
{
	return a + b;
}
int main()
{
	//表示绑定函数plus 参数分别由调用 func1 的第一，二个参数指定
	std::function<int(int, int)> func1 = std::bind(Plus, placeholders::_1, placeholders::_2);
    //auto func1 = std::bind(Plus, placeholders::_1, placeholders::_2);
	cout << func1(1, 2) << endl;//3
}

绑定时第一个参数传入函数指针这个可调用对象，但后续传入的要绑定的参数列表依次是placeholders::_1和placeholders::_2，表示后续调用新生成的可调用对象时，传入的第一个参数传给placeholders::_1，传入的第二个参数传给placeholders::_2。此时绑定后生成的新的可调用对象的传参方式，和原来没有绑定的可调用对象是一样的，也可以称之为无意义的绑定。

调整参数个数：

我可以把Plus函数的第二个参数固定绑定为20，只需要把参数列表的placeholders::_2设置为20即可，此时调用绑定后新生成的可调用对象时就只需要传入一个参数。如下：

int Plus(int a, int b)
{
	return a + b;
}
int main()
{
	//表示绑定函数 plus 的第2个参数为20
    std::function<int(int)> func2 = std::bind(Plus, placeholders::_1, 20);
	cout << func2(5) << endl;//25
}

绑定成员函数：

class Plus
{
public:
	Plus(int x = 2)
		:_x(x)
	{}
	int plusi(int a, int b)
	{
		return (a + b) * _x;
	}
private:
	int _x;
};
int main()
{
	//未绑定，需要传3个参数
	std::function<int(Plus, int, int)> func1 = &Plus::plusi;
	cout << func1(Plus(), 100, 200) << endl;//600
	//绑定后，仅需传2个参数
	std::function<int(int, int)> func2 = std::bind(&Plus::plusi, Plus(10), placeholders::_1, placeholders::_2);
	cout << func2(100, 200) << endl;//3000
	//绑定指定参数，func3的第一个参数已被指定，仅需传1个参数
	std::function<int(int)> func3 = std::bind(&Plus::plusi, Plus(10), 15, placeholders::_1);
	cout << func3(25) << endl;//400
	return 0;
}

通过func1、func2、func3的对比，很明显我func1是直接包装的，需要传3个参数（其中一个隐含的this指针），func2绑定调整过后，也就是把Plus()绑定了，调用时会固定帮我们传一个匿名对象给this指针，也就只需要传2个参数；我func3是绑定调整指定参数，func3的第一个参数已被指定为15，只需要传1个参数即可。

下面来解决一开始引入bind时出现参数个数不匹配的问题：

解决此问题，我们只需要使用绑定来调整参数个数即可：

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 x = 2)
		:_x(x)
	{}
	int plusi(int a, int b)
	{
		return (a + b) * _x;
	}
private:
	int _x;
};
int main()
{
	map<string, std::function<int(int, int)>> opFuncMap =
	{
		{ "普通函数指针", f },
		{ "函数对象", Functor()},
		{ "成员函数指针", std::bind(&Plus::plusi, Plus(10), placeholders::_1, placeholders::_2)}
	};
	cout << opFuncMap["普通函数指针"](1, 2) << endl;//3
	cout << opFuncMap["函数对象"](10, 20) << endl;//30
	cout << opFuncMap["成员函数指针"](100, 200) << endl;//3000
	return 0;
}

此时成员函数指针绑定调整过后，也就是把Plus()绑定了，调用时会固定帮我们传一个匿名对象给this指针，也就只需要传2个参数，就不会出现参数不匹配的情况了。

bind包装器绑定调整参数顺序

对于如下的Sub类的成员函数sub，第一个参数为隐含的this指针，如果想要在调用Sub成员函数时不用对象进行调用this指针，我们可以将sub成员函数的第一个参数固定绑定为一个Sub对象。比如：

class Sub
{
public:
	int sub(int a, int b)
	{
		return a - b;
	}
};
int main()
{
	std::function<int(int, int)> func1 = std::bind(&Sub::sub, Sub(), placeholders::_1, placeholders::_2);
	cout << func1(1, 2) << endl;//-1
	return 0;
}

此时只需要传用于两个相减的参数了，因为在调用时会固定帮我们传一个匿名对象给this指针。

下面如果我想交换两个相减参数的顺序，只需要在绑定时把placeholders::_1和placeholders::_2的位置交换一下即可：

class Sub
{
public:
	int sub(int a, int b)
	{
		return a - b;
	}
};
int main()
{
	//调整顺序
	std::function<int(int, int)> func2 = std::bind(&Sub::sub, Sub(), placeholders::_2, placeholders::_1);
	cout << func2(1, 2) << endl;//1
	return 0;
}

此时实参1传给_2，也就是第二个参数，实参2传给_1，也就是第一个参数，2-1=1。

bind包装器的意义

• 将一个函数的某些参数绑定为固定的值，让我们在调用时可以不用传递某些参数。
• 可以对函数参数的顺序进行灵活调整。