文章目录

1. Lambda表达式
- 1.1. 声明Lambda表达式
- 1.2. 捕获外部变量
- - 1.2.1. 值捕获
  - 1.2.2. 引用捕获
  - 1.2.3. 隐式捕获
  - 1.2.4. 混合方式
- 1.3. Lambda表达式的参数
2. C++11 std::function
- 2.1. 头文件
- 2.2. 作用
- 2.3 std::function 的使用有多态和万总归一的感觉，程序栗子如下：
3. 实例代码

1. Lambda表达式

C++11的一大亮点就是引入了Lambda表达式。利用Lambda表达式，可以方便的定义和创建匿名函数。对于C++这门语言来说来说，“Lambda表达式”或“匿名函数”这些概念听起来好像很深奥，但很多高级语言在很早以前就已经提供了Lambda表达式的功能，如C#，Python等。今天，我们就来简单介绍一下C++中Lambda表达式的简单使用。

1.1. 声明Lambda表达式

Lambda表达式完整的声明格式如下：

[capture list] (params list) mutable exception-> return type { function body }

各项具体含义如下

capture list：捕获外部变量列表
params list：形参列表
mutable指示符：用来说用是否可以修改捕获的变量
exception：异常设定
return type：返回类型
function body：函数体

此外，我们还可以省略其中的某些成分来声明“不完整”的Lambda表达式，常见的有以下几种：

序号	格式
1	[capture list] (params list) -> return type {function body}
2	[capture list] (params list) {function body}
3	[capture list] {function body}

其中：

格式1声明了const类型的表达式，这种类型的表达式不能修改捕获列表中的值。
格式2省略了返回值类型，但编译器可以根据以下规则推断出Lambda表达式的返回类型：

如果function body中存在return语句，则该Lambda表达式的返回类型由return语句的返回类型确定；
如果function body中没有return语句，则返回值为void类型。

格式3中省略了参数列表，类似普通函数中的无参函数。

讲了这么多，我们还没有看到Lambda表达式的庐山真面目，下面我们就举一个实例。

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;bool cmp(int a, int b)
{return  a < b;
}int main()
{vector<int> myvec{ 3, 2, 5, 7, 3, 2 };vector<int> lbvec(myvec);sort(myvec.begin(), myvec.end(), cmp); // 旧式做法cout << "predicate function:" << endl;for (int it : myvec)cout << it << ' ';cout << endl;sort(lbvec.begin(), lbvec.end(), [](int a, int b) -> bool { return a < b; });   // Lambda表达式cout << "lambda expression:" << endl;for (int it : lbvec)cout << it << ' ';
}

在C++11之前，我们使用STL的sort函数，需要提供一个谓词函数。如果使用C++11的Lambda表达式，我们只需要传入一个匿名函数即可，方便简洁，而且代码的可读性也比旧式的做法好多了。

下面，我们就重点介绍一下Lambda表达式各项的具体用法。

1.2. 捕获外部变量

Lambda表达式可以使用其可见范围内的外部变量，但必须明确声明（明确声明哪些外部变量可以被该Lambda表达式使用）。那么，在哪里指定这些外部变量呢？Lambda表达式通过在最前面的方括号[]来明确指明其内部可以访问的外部变量，这一过程也称过Lambda表达式“捕获”了外部变量。

我们通过一个例子来直观地说明一下：

#include <iostream>
using namespace std;int main()
{int a = 123;auto f = [a] { cout << a << endl; }; f(); // 输出：123//或通过“函数体”后面的‘()’传入参数auto x = [](int a){cout << a << endl;}(123);
}

上面这个例子先声明了一个整型变量a，然后再创建Lambda表达式，该表达式“捕获”了a变量，这样在Lambda表达式函数体中就可以获得该变量的值。

类似参数传递方式（值传递、引入传递、指针传递），在Lambda表达式中，外部变量的捕获方式也有值捕获、引用捕获、隐式捕获。

1.2.1. 值捕获

值捕获和参数传递中的值传递类似，被捕获的变量的值在Lambda表达式创建时通过值拷贝的方式传入，因此随后对该变量的修改不会影响影响Lambda表达式中的值。

int main()
{int a = 123;auto f = [a] { cout << a << endl; }; a = 321;f(); // 输出：123
}

这里需要注意的是，如果以传值方式捕获外部变量，则在Lambda表达式函数体中不能修改该外部变量的值。

1.2.2. 引用捕获

使用引用捕获一个外部变量，只需要在捕获列表变量前面加上一个引用说明符&。如下：

int main()
{int a = 123;auto f = [&a] { cout << a << endl; }; a = 321;f(); // 输出：321
}

从示例中可以看出，引用捕获的变量使用的实际上就是该引用所绑定的对象。

1.2.3. 隐式捕获

上面的值捕获和引用捕获都需要我们在捕获列表中显示列出Lambda表达式中使用的外部变量。除此之外，我们还可以让编译器根据函数体中的代码来推断需要捕获哪些变量，这种方式称之为隐式捕获。隐式捕获有两种方式，分别是[=]和[&]。[=]表示以值捕获的方式捕获外部变量，[&]表示以引用捕获的方式捕获外部变量。

隐式值捕获示例：

int main()
{int a = 123;auto f = [=] { cout << a << endl; };    // 值捕获f(); // 输出：123
}

隐式引用捕获示例：

int main()
{int a = 123;auto f = [&] { cout << a << endl; };    // 引用捕获a = 321;f(); // 输出：321
}

1.2.4. 混合方式

上面的例子，要么是值捕获，要么是引用捕获，Lambda表达式还支持混合的方式捕获外部变量，这种方式主要是以上几种捕获方式的组合使用。

到这里，我们来总结一下：C++11中的Lambda表达式捕获外部变量主要有以下形式：

捕获形式	说明
[]	不捕获任何外部变量
[变量名, …]	默认以值得形式捕获指定的多个外部变量（用逗号分隔），如果引用捕获，需要显示声明（使用&说明符）
[this]	以值的形式捕获this指针
[=]	以值的形式捕获所有外部变量
[&]	以引用形式捕获所有外部变量
[=, &x]	变量x以引用形式捕获，其余变量以传值形式捕获
[&, x]	变量x以值的形式捕获，其余变量以引用形式捕获

修改捕获变量
前面我们提到过，在Lambda表达式中，如果以传值方式捕获外部变量，则函数体中不能修改该外部变量，否则会引发编译错误。

Lamba.cpp:24:29: error: increment of read-only variable ‘a’auto f = [a] { cout << a++ << endl; };

那么有没有办法可以修改值捕获的外部变量呢？这是就需要使用mutable关键字，该关键字用以说明表达式体内的代码可以修改值捕获的变量，示例：

复制代码
int main()
{
int a = 123;
auto f = amutable { cout << ++a; }; // 不会报错
cout << a << endl; // 输出：123
f(); // 输出：124
}

1.3. Lambda表达式的参数

Lambda表达式的参数和普通函数的参数类似，那么这里为什么还要拿出来说一下呢？原因是在Lambda表达式中传递参数还有一些限制，主要有以下几点：

参数列表中不能有默认参数
不支持可变参数
所有参数必须有参数名

   {int m = [](int x) { return [](int y) { return y * 2; }(x)+6; }(5);std::cout << "m:" << m << std::endl;            　　//输出m:16std::cout << "n:" << [](int x, int y) { return x + y; }(5, 4) << std::endl;            //输出n:9auto gFunc = [](int x) -> function<int(int)> { return [=](int y) { return x + y; }; };auto lFunc = gFunc(4);std::cout << lFunc(5) << std::endl;auto hFunc = [](const function<int(int)>& f, int z) { return f(z) + 1; };auto a = hFunc(gFunc(7), 8);int a = 111, b = 222;auto func = [=, &b]()mutable { a = 22; b = 333; std::cout << "a:" << a << " b:" << b << std::endl; };func();std::cout << "a:" << a << " b:" << b << std::endl;a = 333;auto func2 = [=, &a] { a = 444; std::cout << "a:" << a << " b:" << b << std::endl; };func2();auto func3 = [](int x) ->function<int(int)> { return [=](int y) { return x + y; }; };std::function<void(int x)> f_display_42 = [](int x) { print_num(x); };f_display_42(44);}

2. C++11 std::function

2.1. 头文件

#include <functional>

2.2. 作用

类模版 std::function 是一种通用、多态的函数封装，形成一个新的可调用的 std::function 对象。std::function的实例可以对任何可以调用对象进行存储、复制和调用操作。std::function 对象是对 C++中现有的可调用实体的一种类型安全的包裹（我们知道像函数指针这类可调用实体，是类型不安全的），就是函数的容器。当我们有了函数的容器之后便能够更加方便的将函数、函数指针作为对象进行处理。

关于可调用对象的概念：对于一个对象或表达式，如果可以对其使用调用运算符，则称该对象或表达式为可调用对象。

可调用对象包括：

（1）函数。

（2）函数指针。

（3）lambda 表达式。

（4）bind 创建的对象。

（5）重载了函数调用运算符的类（仿函数）。

2.3 std::function 的使用有多态和万总归一的感觉，程序栗子如下：

#include <functional>
#include <iostream>std::function<void(std::string)> Functional;// 普通函数。
void TestFunc(std::string str)
{std::cout << str << std::endl;
}// Lambda表达式。
auto lambda = [](std::string str) -> void { std::cout << str << std::endl; };// 仿函数(functor)。
class Functor
{
public:void operator()(std::string str){std::cout << str << std::endl;}
};// 1.类成员函数。
// 2.类静态函数。
class TestClass
{
public:void ClassMember(std::string str){std::cout << str << std::endl;}static void StaticMember(std::string str){std::cout << str << std::endl;}
};int main()
{// 普通函数。Functional = TestFunc;Functional("普通函数");// Lambda表达式。Functional = lambda;Functional("Lambda 表达式");// 仿函数。Functor testFunctor;Functional = testFunctor;Functional("仿函数");// 类成员函数。TestClass testObj;Functional = std::bind(&TestClass::ClassMember, testObj, std::placeholders::_1);Functional("类成员函数");// 类静态函数。Functional = TestClass::StaticMember;Functional("类静态函数");return 0;
}

结果：

普通函数
Lambda 表达式
仿函数
类成员函数
类静态函数

3. 实例代码

#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;int main()
{cout << "************1. 值捕获" << endl;cout << "a = 123" << endl;int a = 123;auto f = [a] { cout << a << endl; }; a = 321;f(); // 输出：123cout << "************2. 引用捕获" << endl;cout << "b = 123" << endl;int b = 123;auto f1 = [&b] { cout << b << endl; }; b = 321;f1(); // 输出：321cout << "************3. 隐式捕获" << endl;cout << "c = 123" << endl;int c = 123;auto f2 = [=] { cout << c << endl; };    // 值捕获f2(); // 输出：123int d = 123;auto f3 = [&] { cout << d << endl; };    // 引用捕获d = 321;f3(); // 输出：321int m = [](int x) { return [](int y) { return y * 2; }(x)+6; }(5); //通过“函数体”后面的‘()’传入参数std::cout << "m:" << m << std::endl;            //输出m:16std::cout << "n:" << [](int x, int y) { return x + y; }(5, 4) << std::endl;            //输出n:9auto gFunc = [](int x)->function<int(int)> { return [=](int y) { return x + y; }; };auto lFunc = gFunc(4);std::cout << lFunc(5) << std::endl;auto hFunc = [](const function<int(int)>& f, int z) { return f(z) + 1; };auto n = hFunc(gFunc(7), 8);int e = 111, h = 222;auto func = [=, &h]()mutable { e = 22; h = 333; std::cout << "e:" << e << " b:" << h << std::endl; };func();std::cout << "e:" << e << " h:" << h << std::endl;int k = 333;auto func2 = [=, &k] { k = 444; std::cout << "k:" << k << " h:" << h << std::endl; };func2();
/*auto func3 = [](int x) ->function<int(int)> { return [=](int y) { return x + y; }; };std::function<void(int x)> f_display_42 = [](int x) { print_num(x); };f_display_42(44);
*/
}

结果：

➜  code_template_c ./build/C++/Lamba/Lamba
************1. 值捕获
a = 123
123
************2. 引用捕获
b = 123
321
************3. 隐式捕获
c = 123
123
321
m:16
n:9
9
e:22 b:333
e:111 h:333
k:444 h:333

原文链接：

https://blog.csdn.net/HarrisJayce/article/details/111054580

https://blog.csdn.net/qq_26079093/article/details/90759175

https://www.cnblogs.com/kekec/p/10904802.html

https://blog.csdn.net/itworld123/article/details/95034012

C++Lambda表达式相关推荐

Lambda 表达式基础理论与示例
Lambda 表达式基础理论与示例 Lambda 表达式,也可称为闭包,推动 Java 8 发布的最重要新特性. Lambda 允许把函数作为一个方法的参数(函数作为参数传递进方法中). 使用 Lam ...
lambda表达式树
一.定义: 表达式树又称为表达式目录树,以数据形式表示语言级代码.所有的数据都存储在树结构中,每个结点表示一个表达式(Expression). 二.要点: –Lambda表达式的参数类型可以忽略,因为 ...
java 8 lambda reduce_JDK8新特性Lambda表达式体验
"Lambda 表达式"(lambda expression)是一个匿名函数,Lambda表达式基于数学中的λ演算得名,直接对应于其中的lambda抽象(lambda abstra ...
java saf_Java 8 Lambda表达式探险
为什么? 我们为什么需要Lambda表达式主要有三个原因: > 更加紧凑的代码比如Java中现有的匿名内部类以及监听器(listeners)和事件处理器(handlers)都显得很冗长 &g ...
lamda表达式python_Python--13 lambda表达式
python 允许使用lambda表达式来创建匿名函数 lambda表达式 >>>def ds(x): ... return 2 * x +1 ... >>> ds ...
C++11:Lambda表达式（匿名函数）理解
C++在C11标准中引入了匿名函数,即没有名字的临时函数,又称之为lambda表达式.lambda表达式实质上是创建一个匿名函数/对象.即你可以理解为(Lambda 表达式实际上是一个函数,只是它没 ...
java8 lambda 表达式详解
lambada 表达式实质上是一个匿名方法,但该方法并非独立执行,而是用于实现由函数式接口定义的唯一抽象方法使用 lambda 表达式时,会创建实现了函数式接口的一个匿名类实例可以将 lambda ...
Java8中Lambda表达式的10个例子
Java8中Lambda表达式的10个例子例1 用Lambda表达式实现Runnable接口 Java代码 //Before Java 8: new Thread(new Runnable() ...
【读书笔记】Lambda表达式
Lambda表达式,是一个匿名函数,它可以包含表达式和语句,并且可用于创建委托或表达式目录树类型. Lambda表达式, 都是用"=>"运算符. 读作"goes t ...
【C++】lambda 表达式
1.lambda 表达式 1.1 lambda 特点 lambda表示一个可调用单元,可视为内联函数范式 : 具有一个返回类型,一个参数列表,一个函数体 [captrue list](paramet ...

C++Lambda表达式