C++匿名函数对象
在C++11及更高版本中，lambda表达式是一种在调用或作为参数传递时在原位定义匿名函数对象的方式。通常，lambda被用于封装几行代码传递给算法或异步函数。以下解释lambda的定义，优点，将其与其他编程技术进行比较，并提供一些基本示例。
C++匿名函数对象
lambda表达式的结构
- [capture] 捕捉列表（lambda引出符）
- (parameters) 参数列表 可选（lambda声明器）
- mutable关键字 可选
- 异常规范 可选
- -> return type返回类型 可选
- lambda函数体
[capture]捕捉列表
[ ] 是lambda引出符。编译器根据该引出符判断接下来的代码是否是lambda函数。捕捉列表能够访问或获取上下文中的变量供lambda函数使用。
lambda 表达式以捕捉列表开头，捕捉列表的功能是指定捕获哪些变量、以及捕获方式。
- 通过引用访问：具有 &前缀的变量
- 通过值访问：无 &前缀的变量
空捕获 [ ]：
- 不从周围捕获变量
在 lambda 表达式中捕获外界变量的默认捕获模式：
- 可以为全部变量默认指定捕获方式，然后为特定变量显式指定模式
[&]：表示所有变量都通过引用捕获[=]：表示所有变量都通过值捕获
引用捕获和值捕获模式的区别：
-
引用捕获可修改外部变量原始数据，值捕获只能修改副本，不能修改原始数据。
-
引用捕获反映外部变量的更新，值捕获不反映。
-
引用捕获引入了生存期依赖关系，值捕获没有生存期依赖关系。如果在异步lambda中通过引用捕获本地，在lambda运行时，本地数据消失会导致运行时访问冲突。
指定捕获模式的不同写法
//lambda主体通过引用访问外部变量total，通过值访问外部变量factor
//顺序不同 等效
[&total, factor]
[factor, &total]
//默认引用捕获 显式指定factor为值捕获
[&, factor]
//默认值捕获 显式指定total为引用捕获
[=, &total]
注意：捕获子句中，顺序不同，但意义等价
变量捕获模式语法
- 变量的前缀不能和捕获子句的捕获默认值重复
- 变量或
this在捕获子句中不能出现多次
struct S { void f(int i); };
void S::f(int i) {
[&, i]{}; // OK
[=, *this]{ }; // OK: *捕获this的地址 默认值捕获
[&, &i]{}; // ERROR: 变量前缀& 和 捕获默认值& 重复
[=, this]{}; // ERROR: 变量值捕获 和 捕获默认值= 重复
[i, i]{}; // ERROR: 变量重复
}
包扩展
语法：[args...]
template<class... Args>
void f(Args... args) {
auto x = [args...] { return g(args...); };
x();
}
要在类成员函数体中使用lambda表达式，需要将this指针传给捕捉列表，才能访问类成员函数和成员对象。this指针可以通过值捕获。值捕获会将整个匿名函数对象复制到调用lambda的每个调用点。
通用捕捉（C++14）
在C++14中，可以在捕捉列表中引入和初始化新变量，无需将这些变量存在于lambda函数的封闭范围中。初始化可以表示为任意表达式，新变量的类型是根据表达式生成的类型推导出来的，能从周围范围捕获仅移动变量（如指针）并在lambda中使用它们。
pNums = make_unique<vector<int>>(nums);
auto a = [ptr = move(pNums)]()
{ use ptr };
(parameters)参数列表
lambda既可以捕获变量，也可以接受输入参数。参数列表是可选的，和函数的参数列表类似。
在C++14中，如果参数类型是泛型的，可以使用auto关键字作为类型说明符，auto关键字会让编译器创建一个调用重载运算符的函数模板。参数列表中的每个auto实例可以等效于不同的类型参数。
auto y = [] (int first, int second)
{
return first + second;
};
//如果参数类型是泛型的 如int，可以使用auto关键字作为类型说明符
auto y = [] (auto first, auto second)
{
return first + second;
};
lambda表达式也可以将另一个lambda表达式作为参数。
如果不向lambda表达式传递参数，且lambda声明符不包含异常规范、尾随返回类型、mutable关键字，可以连同括号“( )”一起省略。
mutable关键字
默认情况下，Lambda函数总是一个const函数，mutable可以取消其常量性。可变规范允许lambda表达式的主体修改由值捕获的变量。在使用该关键字时，参数列表不可省略（即使参数为空）。
异常规范
noexcept异常规范指示lambda表达式没有任何异常，但如果lambda表达式在声明没有异常后用throw关键字抛出异常，则编译器报错。如下所示：
// throw_lambda_expression.cpp
// compile with: /W4 /EHsc
int main() // C4297 expected
{
[]() noexcept { throw 5; }();
}
-> return-type返回类型
lambda表达式的返回类型是自动推导的，一般无需使用auto关键字，除非要指定尾部返回类型。尾部返回类型与普通函数的返回类型相似，不同的是尾部返回类型的声明位置在参数列表之后，且必须在返回类型前加上尾部返回类型关键字->。
- 如果lambda函数主体不返回值，可以省略返回类型，编译器会将返回类型推断为void
- 如果lambda主体返回值，编译器会根据返回值推断返回类型
考虑以下示例代码片段来说明这一原则：
auto x1 = [](int i){ return i; }; // OK: 返回类型为int
auto x2 = []{ return{ 1, 2 }; }; // ERROR: 返回类型为空,无法从大括号列表推断返回类型
注：lambda表达式可以生成另一个lambda表达式作为其返回值。
lambda函数体
lambda表达式的函数主体是一个复合语句，包含的内容与普通函数或成员函数体类似。lambda函数体可以访问的变量：
-
从上下文捕获变量
-
参数
-
本地变量
-
类数据成员：声明在类内部，使用this指针捕获
-
静态变量，例如全局变量
以下示例包含一个lambda表达式，该表达式通过值显式捕获变量n，通过引用隐式捕获变量m：
因为变量n为值捕获，所以调用 lambda表达式后，其原始值仍为0。mutable关键字允许在lambda中修改n的拷贝对象。
#include <iostream>
using namespace std;
int main()
{
int m = 0;
int n = 0;
[&, n] (int a) mutable { m = ++n + a; }(4);
cout << m << endl << n << endl;
}
lambda表达式只能捕获具有auto关键字的变量，但lambda函数体中可以使用静态变量。
以下示例使用generate函数和lambda表达式为向量对象中的每个元素赋值。lambda表达式修改静态变量以生成下一个元素的值。
void fillVector(vector<int>& v)
{
// 局部静态变量
static int nextValue = 1;
// lambda表达式修改局部静态变量为vector元素赋值
generate(v.begin(), v.end(), [] { return nextValue++; });
//注意：这不是线程安全的
}
以下代码示例使用lambda表达式将向量对象的一个元素指定给前两个元素的和：
lambda表达式通过值捕获这些变量，所以在运行结束之后变量的值不变。
注意：如果lambda表达式调用了外部静态变量，那么每次执行后的结果会和前一次不一样
#include <algorithm>
#include <iostream>
#include <vector>
#include <string>
using namespace std;
template <typename C> void print(const string& s, const C& c) {
cout << s;
for (const auto& e : c) {
cout << e << " ";
}
cout << endl;
}
void fillVector(vector<int>& v)
{
static int nextValue = 1;
generate(v.begin(), v.end(), [] { return nextValue++; });
}
int main()
{
// vector中元素个数
const int elementCount = 9;
// 将vector中每个元素的值设置为1
vector<int> v(elementCount, 1);
// vector中两个数字的起始值
int x = 1;
int y = 1;
generate_n(v.begin() + 2,elementCount - 2,[=]() mutable throw() -> int {
int n = x + y;
x = y;
y = n;
return n;
});
// 打印v经过generate_n的结果
print("vector v after call to generate_n() with lambda: ", v);
// 输出x y的值，因为x y是值捕获，所以值仍然是1
cout << "x: " << x << " y: " << y << endl;
// 使用fillVector填充v
fillVector(v);
print("vector v after 1st call to fillVector(): ", v);
// 使用fillVector第二次填充v
// 因为fillVector使用了静态变量 所以第二次填充的结果和第一次不一样
fillVector(v);
print("vector v after 2nd call to fillVector(): ", v);
}
constexpr lambda表达式(c++17)
当常量表达式允许初始化每个捕获或引入的数据成员时，可以将lambda表达式声明为constexpr（或在常量表达式中使用它）。
int y = 32;
auto answer = [y]() constexpr
{
int x = 10;
return y + x;
};
constexpr int Increment(int n)
{
return [n] { return n + 1; }();
}
如果lambda表达式的结果满足constexpr函数的要求，其数据类型将隐式为constexpr：
auto answer = [](int n)
{
return 32 + n;
};
constexpr int response = answer(10);
如果lambda隐式或显式为constexpr，则转换为函数指针将生成constexpr函数：
auto Increment = [](int n)
{
return n + 1;
};
constexpr int(*inc)(int) = Increment;
constexpr关键字(c++11)
constexpr是C++11新增关键字，语义是“常量表达式”，也就是在编译期可求值的表达式。
最基础的常量表达式就是字面值或全局变量、函数的地址、sizeof等关键字返回的结果，常量表达式都是由基础表达式通过各种确定的运算得到的。
constexpr值可用于enum、switch、数组长度等。
constexpr修饰变量
constexpr所修饰的变量一定是编译期可求值的，所修饰的函数在其所有参数都是constexpr时，一定会返回constexpr。
constexpr int Inc( int i) {
return i + 1;
}
constexpr int a = Inc(1); // ok
constexpr int b = Inc(cin.get()); // constexpr所修饰的变量一定是编译期可求值的，cin编译期不可求值
constexpr int c = a * 2 + 1; // ok
constexpr修饰类的构造函数
constexpr修饰类的构造函数，如果能保证提供给该构造函数的参数都是constexpr，那么产生的对象中的所有成员都会是constexpr，可用于各种只能使用constexpr的场合。
注意：constexpr构造函数的函数体必须为空，所有成员变量的初始化必须在初始化列表中。
struct A {
constexpr A( int xx, int yy): x(xx), y(yy) {}
int x, y;
};
constexpr A a(1, 2);
enum {SIZE_X = a.x, SIZE_Y = a.y};
constexpr的优点
- 是一种很强的约束，更好地保证程序的正确语义不被破坏
- 编译器可以在编译期对constexpr的代码进行非常大的优化，比如将用到的constexpr表达式都直接替换成最终结果等
- 相比宏来说，没有额外的开销，但更安全可靠
特定于Microsoft
以下公共语言运行时（CLR）托管实体中不支持lambda：
ref class、ref struct、value class或value struct。
如果使用Microsoft的特定修饰符，如declspec，则可以在参数声明后立即将其插入lambda表达式中。例如：
auto Sqr = [](int t) __declspec(code_seg("PagedMem")) -> int { return t*t; };
865
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
