一.lambda表达式
lambda表达式就是定义了一个可调用的匿名函数，一般在局部。
1.格式
lambda表达式书写格式：**[capture-list] (parameters) mutable -> return-type { statement **
}
[capture-list] (parameters) mutable -> return-type { statement }
捕捉列表 参数 去const（单词意思易变的） 返回值 函数体
auto Add1 = [ ](int x, int y)->int {return (x + y); };
2. lambda表达式各部分说明
（1）[capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，**编译器根据[]来 **
判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda****函数使用。
捕捉的参数都是自带const的，想要去掉const属性可以用
mutable，但是捕捉的对象(变量)仍是一份拷贝，外部的a，b无法被修改，所以mutable 很少用，意义不大，不如用 [&]引用捕捉 ( )引用传参
（2）(parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以
连同()一起省略。所传参数都是
（3）mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量
性。使用该修饰符时，参数列表不可省略(即使参数为空时，也要带上小括号)。mutable 只是让传值捕捉变量const属性去掉了，但是捕捉的a，b仍是拷贝，外部的a，b无法被修改，所以mutable 很少用，意义不大
（4）**->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型**，没有返回
值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推****导。
（5）**{statement}：函数体**。在该函数体内，除了可以使用其参数外，还可以使用所有捕获
到的变量。
**注意： **
在lambda函数定义中，**参数列表和返回值类型都是可省略部分，而捕捉列表和函数体可以为 **
空，但不可省略，因此C++11中最简单的lambda函数为：[]{}; 该lambda函数不能做任何事情。
3.举例
（1）例子1：相加函数
int a = 0, b = 200;
// [capture-list] (parameters) mutable -> return-type { statement }
// 捕捉列表 参数 返回值 函数体
// 一般是局部匿名函数 也可以写到全局
auto Add1 = [](int x, int y)->double {return (x + y) / 3.0; };
auto Add2 = [](int x, int y)->int {return (x + y) / 3.0; };//传参写法
auto Add3 = [a, b] {return (a + b) / 3.0; };//捕捉变量写法
cout << Add1(a, b) << endl;
cout << Add2(a, b) << endl;
cout << Add3() << endl;
（2）[ ]捕捉列表 例子2：交换函数
3,4,5,6是几种捕捉方式
1. auto Swap1 = [](int& x, int& y){
int tmp = x;
x = y;
y = tmp;
};
Swap1(a, b);
cout << a << " " << b << endl;
2. mutable 只是让传值捕捉变量const属性去掉了，但是捕捉的a，b仍是拷贝，外部的a，b无法被修改
/*auto Swap2 = [a, b]()mutable{
int tmp = a;
a = b;
b = tmp;
};*/
用引用的方式捕捉:
auto Swap2 = [&a, &b]{
int tmp = a;
a = b;
b = tmp;
};
Swap2();
cout << a << " " << b << endl;
3. int c =2, d=3, e=4, f=5, g=6, ret;
传值捕捉全部对象
auto Func1 = [=]{
return c + d*e / f + g;
};
cout << Func1() << endl;
4. 传引用捕捉全部对象
auto Func2 = [&]{
ret = c + d*e / f + g;
};
Func2();
cout << ret << endl;
5. 混着捕捉
auto Func3 = [c, d, &ret]{
ret = c + d;
};
Func3();
cout << ret << endl;
6. ret传引用捕捉 其他全部传值捕捉
auto Func4 = [=, &ret]{
ret = c + d*e / f + g;
//c = 1;
};
Func4();
cout << ret << endl;
仿函数比较，lambda更易懂
struct Goods
{
string _name; // 名字
double _price; // 价格
int _evaluate; // 评价
Goods(const char* str, double price, int evaluate)
:_name(str)
, _price(price)
, _evaluate(evaluate)
{}
};
struct Compare1
{
bool operator()(const Goods& gl, const Goods& gr)
{
return gl._evaluate < gr._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()
{
// C/C++98
int i = 0;
double d1 = i;
const double& d2 = i;
// C++98
string str1 = "11111";
const string& str2 = "11111";
// C++11
Goods g1 = { "苹果", 2.1, 5 };
const Goods& g2 = { "苹果", 2.1, 5 };
vector<Goods> v = { Goods( "苹果", 2.1, 5 ), { "香蕉", 3, 4 }, { "橙子", 2.2, 3 }, { "菠萝", 1.5, 4 } };
//sort(v.begin(), v.end()); 自定义类型没重载<不能用less或者greater
sort(v.begin(), v.end(), Compare1());
sort(v.begin(), v.end(), ComparePriceLess());
sort(v.begin(), v.end(), ComparePriceGreater());
1. auto com1 = [](const Goods& g1, const Goods& g2){return g1._price < g2._price; };
sort(v.begin(), v.end(), com1);
2. sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){
return g1._price < g2._price; });
cout << endl;
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){
return g1._price > g2._price; });
cout << endl;
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){
return g1._evaluate < g2._evaluate; });
cout << endl;
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){
return g1._evaluate > g2._evaluate; });
cout << endl;
return 0;
}
4.lambda注意点
（1）**父作用域指包含lambda函数的语句块 **
（2） 语法上捕捉列表可由多个捕捉项组成，并以逗号分割。
比如：[=, &a, &b]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量
[&，a, this]：值传递方式捕捉变量a和this，引用方式捕捉其他变量
（3）捕捉列表不允许变量重复传递，否则就会导致编译错误。
比如：[=, a]：=已经以值传递方式捕捉了所有变量，捕捉a重复
（4） 在块作用域以外的lambda函数捕捉列表必须为空。
（5）在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者
非局部变量（捕捉 全局变量会报错）都会导致编译报错。
（6）lambda对象之间不能相互赋值，即使看起来类型相同，因为每个lambda都会被转换成一个仿函数类型，仿函数类名称lambda+ uuid。（
lambda表达式底层被转换成仿函数）
但是允许使用lambda表达式拷贝构造
也可以将lambda表达式赋值给相同类型的函数指针，了解一下，一般不建议这么用，意义不大
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;
}
5.底层原理
lambda表达式底层是一个仿函数。每个lambda都会被转换成一个仿函数类型，仿函数类名称lambda+ uuid。
二.包装器
1.可调用类型对象
1、函数指针
2、仿函数对象
3、lambda
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*函数模板实例化了三份。 **
包装器可以很好的解决上面的问题
2.**function包装器 **
template <class Ret, class... Args>
class function<Ret(Args...)>;
模板参数说明：
Ret: 被调用函数的返回类型
Args…：被调用函数的形参
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;
std::function<int(int, int)> func2 = Functor();
cout << func2(10, 20) << endl;
静态成员函数包装可以加&也可以不加
std::function<int(int, int)> func3 = &Plus::plusi;
cout << func3(100, 200) << endl;
规定：非静态成员函数包装必须加&，和域名，参数多一个域
std::function<double(Plus, double, double)> func4 = &Plus::plusd;
cout << func4(Plus(), 100.11, 200.11) << endl;
std::function<int(int, int)> func5 = [](int a, int b) {return a + b; };
cout << func5(100, 200) << endl;
return 0;
}
#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;
}
3.**bind **
std::bind函数定义在头文件中，**是一个函数模板，它就像一个函数包装器(适配器)，接受一个可 **
调用对象（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为第二个参数，以此类推。
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()
{
std::function<int(int, int)> func1 = f;
cout << func1(1, 2) << endl;
std::function<int(int, int)> func2 = Functor();
cout << func2(10, 20) << endl;
// 3个参数
std::function<int(Plus, int, int)> func3 = &Plus::plusi;
cout << func3(Plus(), 100, 200) << endl;
// 调整可调用对象的参数个数和顺序
// _1 _2 _3... 表示你要自己传的那些参数，_1表示第一个参数传给_1
// 调整个数
// 2个参数
std::function<int(int, int)> func4 = std::bind(&Plus::plusi, Plus(10), placeholders::_1, placeholders::_2);
// 1个参数
std::function<int(int)> func5 = std::bind(&Plus::plusi, Plus(10),
10, placeholders::_1);
cout << func5(200) << endl;
// 调整顺序 -- 用处不大
std::function<int(int, int)> func6 = std::bind(f, placeholders::_2, placeholders::_1);
cout << func1(66, 77) << endl;
cout << func6(66, 77) << endl;
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;
cout << opFuncMap["函数对象"](1, 2) << endl;
cout << opFuncMap["成员函数指针"](1, 2) << endl;
return 0;
}
版权归原作者 beyond.myself 所有， 如有侵权，请联系我们删除。