C++11——包装器与lambda表达式

一.背景

二.lambda

1.见一见lambda

2.lambda表达式语法

3.lambda捕捉列表说明

三.函数对象与lambda表达式

四.包装器

1.function包装器

2.包装类的成员函数

五.bind

1.调整参数位置

2.减少函数参数

一.背景

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

#include<algorithm>
#include<vector>
using namespace std;void Print(vector<int>& arr)
{for (auto e : arr){cout << e << " ";}cout << endl;
}int main()
{vector<int> arr = { 4,1,8,5,3,7,0,9,2,6 };//降序sort(arr.begin(), arr.end(),greater<int>());Print(arr);//升序sort(arr.begin(), arr.end());Print(arr);return 0;
}

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

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;}
};void Print(vector<Goods>& v)
{for (auto e : v){cout << e._name << ":" << e._price << ":" << e._evaluate << endl;}cout << endl;
}
int main()
{vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,3 }, { "菠萝", 1.5, 4 } };sort(v.begin(), v.end(), ComparePriceLess());Print(v);sort(v.begin(), v.end(), ComparePriceGreater());Print(v);return 0;
}

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

二.lambda

1.见一见lambda

改装上面的代码：

struct Goods
{string _name;  //名字double _price; //价格int _evaluate; //评价Goods(const char* str, double price, int evaluate):_name(str), _price(price), _evaluate(evaluate){}
};void Print(vector<Goods>& v)
{for (auto e : v){cout << e._name << ":" << e._price << ":" << e._evaluate << endl;}cout << endl;
}
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)->bool {return g1._price < g2._price; });Print(v);sort(v.begin(), v.end(), [](const Goods g1, const Goods g2)->bool {return g1._price > g2._price; });Print(v);return 0;
}

上述代码就是使用C++11中的lambda表达式来解决，可以看出lambda表达式实际是一个匿名函
数。

2.lambda表达式语法

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

[capture-list] :

捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。

int main()
{int a = 100;int b = 200;int sum = 0;auto lam = [a, b]()->int {return a + b; };sum = lam();cout << "a + b = "<<sum << endl;return 0;
}

(parameters)：

参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略。

int main()
{int a = 100;int b = 200;int sum = 0;auto lam = [](int a,int b)->int {return a + b; };sum = lam(a,b);cout << "a + b = "<<sum << endl;return 0;
}

mutable：

默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)。

默认对捕捉的变量有const属性：

int main()
{int a = 100;int b = 200;int sum = 0;auto lam = [a,b](){a = b = 50;cout << "a:" << a << endl;cout << "b:" << b << endl;};lam();cout << "a:" << a << endl;cout << "b:" << b << endl;return 0;
}

加上mutable关键字：

注意：

使得lambda捕捉的变量失去const属性，但是不说变量的修改的范围仅限于lambda表达式的内部。
在lambda的外部数据仍旧是外部的值。

->returntype：

返回值类型。
用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。
返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。

{statement}：

函数体，在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。

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

3.lambda捕捉列表说明

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

[var]：表示值传递方式捕捉变量var。

int main()
{int a = 100;int b = 200;int sum = 0;auto lam1 = [a](){cout << a << endl;};lam1();return 0;
}

[=]：表示值传递方式捕获所有父作用域中的变量(包括this)。

int main()
{int a = 100;int b = 200;int sum = 0;auto lam1 = [=](){cout << a << endl;cout << b << endl;};lam1();return 0;
}

[&var]：表示引用传递捕捉变量var。

int main()
{int a = 100;int b = 200;int sum = 0;auto lam1 = [&a](){a = 500;};lam1();cout << "a:" << a;return 0;
}

[&]：表示引用传递捕捉所有父作用域中的变量(包括this)。

int main()
{int a = 100;int b = 200;int sum = 0;auto lam1 = [&](){a = b = 50;};lam1();cout << "a:" << a << endl;cout << "b:" << b << endl;return 0;
}

[this]：表示值传递方式捕捉当前的this指针。

class Test
{
public:Test(int a):_a(a){}void operator()(){//捕捉this指针之后，无需使用this类指定成员，可以直接访问类成员auto Prin_a = [this]() {cout <<"class Teat::_a:" << _a << endl; };Prin_a();}private:int _a;};int main()
{Test T(100);T();return 0;
}

注意：捕捉this指针之后，无需使用this类指定成员，可以直接访问类成员。

三.函数对象与lambda表达式

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

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);// lamberauto r2 = [=](double monty, int year)->double {return monty * rate * year;};r2(10000, 2);return 0;
}

从使用方式上来看，函数对象与lambda表达式完全一样。
函数对象将rate作为其成员变量，在定义对象时给出初始值即可，lambda表达式通过捕获列表可
以直接将该变量捕获到。

UUID 是通用唯一识别码（Universally Unique Identifier）的缩写，是一种软件建构的标准，亦为开放软件基金会组织在分布式计算环境领域的一部分。其目的，是让分布式系统中的所有元素，都能有唯一的辨识信息，而不需要通过中央控制端来做辨识信息的指定。

实际在底层编译器对于lambda表达式的处理方式，完全就是按照函数对象的方式处理的，即：如
果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator()。

四.包装器

1.function包装器

function包装器也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。那么我们来看看，我们为什么需要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;// lamber表达式cout << useF([](double d)->double { return d / 4; }, 11.11) << endl;return 0;
}

通过上面的程序验证，我们会发现useF函数模板实例化了三份，产生这个的原因是，即使这三个可调用对象的功能都是一模一样的，但是由于三个可调用对象，一个是函数，一个是类对象，一个是lambda表达式，是三种不同的类型，所以也就导致了模板在实例化的时候，会实例化出三份useF函数。

包装器可以很好的解决上面的问题：

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

包装上述可调用对象：

#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()
{function<double(double)> func1 = f;function<double(double)> func2 = Functor();function<double(double)> func3 = [](double d) {return d / 1; };useF<function<double(double)>, double>(func1, 11.11);useF<function<double(double)>, double>(func2, 11.11);useF<function<double(double)>, double>(func3, 11.11);return 0;
}

2.包装类的成员函数

对于类的成员函数，针对静态成员函数与普通函数几乎没有差异，针对类的普通成员函数，我们需要在包装的时候，传递一个类的对象，或者类的对象的指针。

class Add
{
public:Add(int a):_a(a){}int add(int b){return _a + b;}static int s_add(int a, int b){return a + b;}
private:int _a;
};int main()
{//包装非静态成员函数,用对象构建function<int(Add, int)> fun1 = &Add::add;cout << fun1(Add(10), 30) << endl;//包装非静态成员函数，用对象指针构建Add add(10);function<int(Add*, int)> fun3 = &Add::add;cout << fun3(&add, 30) << endl;//包装静态成员函数function<int(int,int)> fun2 = Add::s_add;cout << fun2(10, 30) << endl;return 0;
}

注意：包装类的非静态成员函数，使用类对象的指针包装，就不能在调用的时候用匿名对象传参，因为只有左值才能取地址。

五.bind

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

// 原型如下：
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函数看作是一个通用的函数适配器，它接受一个可调用对象，生成一个新的可调用对
象来“适应”原对象的参数列表。
调用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.调整参数位置

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

2.减少函数参数

通过指定一个位置的参数，在调用时少传一个参数。

 class Add
{
public:Add(int c):_c(c){}int add(int a,int b){return (a + b) * _c;}
private:int _c;
};int main()
{//包装非静态成员函数,用对象构建function<int(Add, int,int)> fun1 = &Add::add;cout << fun1(Add(10), 3,2) << endl;//包装非静态成员函数,用对象构建//指定一个参数Add(10)作为参数，剩余参数正常传参function<int(int,int)> fun2 = bind(&Add::add, Add(10), placeholders::_1, placeholders::_2);cout << fun2(3,2) << endl;return 0;
}