lambda 表达式简介
lambda表达式是C++11最重要也最常用的一个特性之一，其实在C#3.5中就引入了lambda，Java8中也引入了lambda表达式
lambda 来源于函数式编程的概念，也是现在编程语言的一个特点，有如下优点：
- 声明式编程风格：就地匿名定义目标函数或函数对象，不需要额外写一个命名函数或者对象，以更直接的方式去写程序，好的可读性和可维护性
- 简洁：不需要额外再写一个函数或者函数对象，避免了代码膨胀和功能分散，让开发者更加集中精力在手边的问题，同时也获取了更高的生产率
- 在需要的时间和地点实现功能闭包，使程序更灵活
lambda 表达式的基本概念和基本用法
lambda表达式定义了一个匿名函数，并且可以捕获一定范围内的变量，lambda表达式的语法形式可简单归纳如下：
[caoture] (params) opt -> ret {body;};
其中：capture是捕获列表；params是参数表；opt是函数选项；ret是返回值类型；body是函数体，因此一个完整的lambda表达式看起来就像这样：
int main()
{
auto f = [](int a) -> int {return a + 1; };
//捕获列表
cout << f(1) << endl;
}
int main()
{
auto f = [](int a) {return a; };
//直接推导类型 可以省略 -> int
auto f = [](int a) ->std::initializer_list<int> {return { a,1 }; };
//auto f = [](int a) {return { a,1 }; }; 无法推到出
}
lambda 表达式可以通过获取列表捕获一定范围内的变量：
- [] 不捕获任何变量
- [&] 捕获外部作用域中所有变量，并作为引用在函数体中使用（按引用捕获）
- [=] 捕获外部作用域中所有变量，并作为副本在函数体中使用（按值捕获）
- [=,&foo] 按值捕获外部作用域中所有变量，并按引用获取foo变量
- [bar] 按值捕获bar变量，同时不捕获其他变量
- [this] 捕获当前类中的this指针，让lambda表达式拥有和当前类成员同样的访问权限，如果已经使用了&或者=，就默认添加此选项，捕获this的目的是可以在lambda中使用当前类的成员函数和成员变量
int g_max = 10; //全局变量 没有捕获的概念,可以直接使用
int add(int x, int y)
{
return x + y;
}
int fun(int x)
{
int sum = 10;
int num = 20;
auto f1 = [](int a) -> int {return a + g_max; };
//[] 不捕获任何变量 ，sum num 都不能使用
auto f2 = [&](int a) -> int
{
x = a;
sum += 10;
num = a + x;
return num;
};
//在此仿函数内，对sum num 有读写能力
list<int> ar = { 12,23,34,45,56,67,78,89 };
ar.sort([&](int a, int b)->bool {return a < b; });
return 0;
}
int main()
{
/*
// error!!!
auto f3 = [&](int a) -> int
{
x = a;
sum += 10;
num = a + x;
return num;
};
//只能捕获，存在于该函数内的局部变量与形参
*/
list<int> ar = { 34,23,45,67,12,56,78,89 };
ar.sort([](int a, int b)->bool {return a > b; });
//类似于仿函数，由大到小
for (auto& x : ar)
{
cout << x << endl;
}
}
从下面代码，捕获方式的不同可以看出，编译时就进行了捕获
// 可以类比为下面样子
class F1
{
int& x;
public:
F1(int& a) :x(a) {}
};
class F2
{
int x;
public:
F2(int a) :x(a) {}
int operator()(int a)const
{
//x += 10; error!!!
}
};
int main()
{
int x = 0;
auto f1 = [&](int a) -> int
{
x += 10;
cout << x << endl;
return x;
};
auto f2 = [=](int a)->int
{
return x;
//编译时候就进行捕获
//function的一个变种 捕获x，将int x = 0；进行赋值作为一个副本
//不能进行 x+=10；某种意义上说是一个常量
};
x = 100;
cout << f1(0) << endl;
cout << f2(0) << endl;
return 0;
}
在下面的代码中，x2 按值进行捕获，可以对a，和g_max进行捕获，并且对this指针进行了捕获，继而可以去使用value
int g_max = 10;
class Object
{
int value;
public:
Object(int x = 0) :value(x) {}
void func(int a, int b)
{
auto x0 = []()->int {return g_max; };
auto x1 = []()->int {return a; }; // errror
auto x2 = [=]()->int
{
int x = value;
return x + a + g_max;
};
}
}
虽然我们上面说了，按值捕获在某种意义上是一种常量，但是此处捕获的实际为this指针，所以可以对value值进行修改
auto x3 = [=]() ->int
{
value += 10;
int x = value;
return x + a + g_max;
};
mutable
class Object
{
int value;
mutable int num;
public:
Object(int x = 0,int y = 0):value(x),num(y){}
int fun()const
{
num += 10; //加了mutable关键字 可以修改
return value + num;
}
};
int main()
{
int a = 0;
auto f1 = [=] {return a++; }; //error
auto f2 = [=]() mutable {return a++; }; //可变的
//这里的a是上面a的一个副本
}
mutable关键字后，由于捕获为[=]，所以lambda表达式中存放的是一个副本
class F1
{
int _a;
public:
F1(int x) :_a(x){}
int operator()() const
{
_a += 10;
return a;
}
};
//下面f1 可以类比为上面，首先嗲东构造函数，初始化_a，然后调用括号运算符重载，最终得出20
int main()
{
int a = 10;
auto f1 = [=]()mutable->int
{
a += 10;
return a;
};
a += 100;
cout << "f1:" << f1() << endl;
cout << "a:" << a << endl;
}
函数，仿函数，lambda表达式
template<class _BI, class _Fn>
void my_for_each(_BI _first, _BI _last, _Fn _func)
{
cout << typeid(_Fn).name() << endl;
for (; _first != _last; ++_first)
{
_func(*_first);
}
}
void Print_Ar(int x)
{
printf(" %d ", x);
}
struct Print
{
void operator()(int x) const
{
printf(" %d ", x);
}
};
int main()
{
std::vector<int> ar = { 12,23,34,45,56,67,78 };
my_for_each(ar.begin(), ar.end(), Print_Ar);
cout << endl;
my_for_each(ar.begin(), ar.end(), Print());
cout << endl;
my_for_each(ar.begin(), ar.end(), [](int a)->void {printf(" %d ", a); });
return 0;
}
lambda表达式其实就是仿函数的语法糖
