C++11 の新機能と組み合わせて、C++ でのラムダ式の使用法を学習します。

C++11 では、ラムダ式 (多くの場合「ラムダ」と呼ばれます) は、関数が呼び出される時点、または関数の引数として渡される時点で匿名関数オブジェクトを定義する便利な方法です。ラムダは通常、アルゴリズムまたは非同期メソッドに渡される少数のコード行をカプセル化するために使用されます。 この記事では、ラムダとは何かを定義し、ラムダと他のプログラミング手法を比較し、その利点について説明し、基本的な例を示します。
ラムダ式の一部
ISO C++ 標準では、std::sort() 関数の 3 番目の引数として渡される単純なラムダが示されています。

#include <algorithm>
#include <cmath>
 
void abssort(float* x, unsigned n) {
 std::sort(x, x + n,
 // Lambda expression begins
 [](float a, float b) {
  return (std::abs(a) < std::abs(b));
 } // end of lambda expression
 );
}

この図は、ラムダのコンポーネントを示しています。

Capture 句 (C++ 仕様ではラムダ ブートストラップとも呼ばれます。)

パラメータ リスト (オプション)。 (ラムダ宣言子とも呼ばれます)

変数の仕様 (オプション)。

例外仕様 (オプション)。

末尾の戻り値の型 (オプション)。

「ラムダ本体」

Capture 句

Lambda は、その本体 (C++14 の場合) に新しい変数を導入でき、周囲のスコープ内の変数にアクセス (または「キャプチャ」) することもできます。ラムダは Capture 句 (標準構文のラムダ ブートストラップ) で始まり、キャプチャする変数と、値または参照のどちらでキャプチャするかを指定します。 アンパサンド (&) の接頭辞が付いている変数は参照によってアクセスされ、この接頭辞のない変数は値によってアクセスされます。

空のキャプチャ句 [ ] は、ラムダ式の本体が外側のスコープ内の変数にアクセスしないことを示します。

デフォルトのキャプチャ モード (標準構文では capture-default) を使用して、ラムダで参照される外部変数をキャプチャする方法を指定できます。[&] は参照によって参照されるすべての変数をキャプチャすることを意味し、[=] は値によってキャプチャすることを意味します。 。 デフォルトのキャプチャ モードを使用してから、特定の変数に対して反対のモードを明示的に指定できます。 たとえば、ラムダ本体が参照によって外部変数 total にアクセスし、値によって外部変数係数にアクセスする場合、次のキャプチャ句は同等です:

[&total, factor]
[factor, &total]
[&, factor]
[factor, &]
[=, &total]
[&total, =]

capture-default を使用する場合、ラムダで言及されている変数のみがアクセスされます。捕らえられる。

キャプチャ句に Capture-default& が含まれる場合、そのキャプチャ句の識別子内のキャプチャは & 識別子の形式をとることはできません。 同様に、キャプチャ句に Capture-default= が含まれる場合、キャプチャ句のキャプチャは = 識別子の形式をとることはできません。 identifier または this は、キャプチャ句内で複数回使用できません。 次のコード スニペットはいくつかの例を示しています。次の可変引数テンプレートの例に示すように、

struct S { void f(int i); };
 
void S::f(int i) {
 [&, i]{}; // OK
 [&, &i]{}; // ERROR: i preceded by & when & is the default
 [=, this]{}; // ERROR: this when = is the default
 [i, i]{}; // ERROR: i repeated
}

capture の後に省略記号が続くものは、パッケージ拡張です。

template<class... Args>
void f(Args... args) {
 auto x = [args...] { return g(args...); };
 x();
}

クラス メソッドの本体でラムダ式を使用するには、 this ポインタを次のメソッドに渡します。 Capture 句を使用して、囲んでいるクラスのメソッドとデータ メンバーへのアクセスを提供します。 クラス メソッドでラムダ式を使用する方法を示す例については、「ラムダ式の例」の「例: メソッドでのラムダ式の使用」を参照してください。

capture 句を使用するときは、次の点に留意することをお勧めします (特に複数のスレッドを取るラムダを使用する場合):

参照キャプチャは外部変数の変更に使用できますが、値キャプチャではこの操作を実現できません。 (ミュータブルでは、コピーの変更は許可されますが、オリジナルの変更は許可されません。)

参照キャプチャは外部変数への更新を反映しますが、値キャプチャは反映しません。

参照キャプチャには存続期間依存関係が導入されますが、値キャプチャには存続期間依存関係がありません。 これは、ラムダが非同期で実行される場合に特に重要です。 非同期ラムダでローカル変数を参照によってキャプチャすると、ラムダの実行時にローカル変数が消失する可能性が高く、ランタイム アクセス違反が発生します。

ユニバーサル キャプチャ (C++14)
C++14 では、ラムダ関数の囲みスコープ内に新しい変数が存在しなくても、Capture 句で新しい変数を導入して初期化できます。 初期化は任意の式で表すことができ、新しい変数の型はその式で生成された型から推定されます。 この機能の利点の 1 つは、C++14 では、移動専用変数 (std::unique_ptr など) を周囲のスコープからキャプチャしてラムダで使用できることです。

pNums = make_unique<vector<int>>(nums);
//...
 auto a = [ptr = move(pNums)]()
 {
  // use ptr
 };

パラメータリスト

ラムダは変数をキャプチャするだけでなく、入力パラメータも受け入れることができます。 引数リスト (標準構文ではラムダ宣言子と呼ばれます) はオプションであり、ほとんどの点で関数の引数リストに似ています。

int y = [] (int first, int second)
{
 return first + second;
};

C++14 では、パラメーターの型がジェネリックの場合、型指定子として auto キーワードを使用できます。 これは、関数呼び出し演算子をテンプレートとして作成するようにコンパイラーに指示します。 パラメーター リスト内の auto の各インスタンスは、異なる型パラメーターと同等です。

りー

lambda 表达式可以将另一个 lambda 表达式作为其参数。 有关详细信息，请参阅 Lambda 表达式的示例主题中的“高阶 Lambda 表达式”。
由于参数列表是可选的，因此在不将参数传递到 lambda 表达式，并且其 lambda-declarator: 不包含 exception-specification、trailing-return-type 或 mutable 的情况下，可以省略空括号。

可变规范
通常，lambda 的函数调用运算符为 const-by-value，但对 mutable 关键字的使用可将其取消。 它不会生成可变的数据成员。 利用可变规范，lambda 表达式的主体可以修改通过值捕获的变量。 本文后面的一些示例将显示如何使用 mutable。
异常规范
你可以使用 throw() 异常规范来指示 lambda 表达式不会引发任何异常。 与普通函数一样，如果 lambda 表达式声明 C4297 异常规范且 lambda 体引发异常，Visual C++ 编译器将生成警告 throw()，如下所示：

// throw_lambda_expression.cpp
// compile with: /W4 /EHsc
int main() // C4297 expected
{
 []() throw() { throw 5; }();
}

返回类型
将自动推导 lambda 表达式的返回类型。 无需使用 auto 关键字，除非指定尾随返回类型。 trailing-return-type 类似于普通方法或函数的返回类型部分。 但是，返回类型必须跟在参数列表的后面，你必须在返回类型前面包含 trailing-return-type 关键字 ->。
如果 lambda 体仅包含一个返回语句或其表达式不返回值，则可以省略 lambda 表达式的返回类型部分。 如果 lambda 体包含单个返回语句，编译器将从返回表达式的类型推导返回类型。 否则，编译器会将返回类型推导为 void。 下面的代码示例片段说明了这一原则。

auto x1 = [](int i){ return i; }; // OK: return type is int
auto x2 = []{ return{ 1, 2 }; }; // ERROR: return type is void, deducing
     // return type from braced-init-list is not valid

   

lambda 表达式可以生成另一个 lambda 表达式作为其返回值。 有关详细信息，请参阅 Lambda 表达式的示例中的“高阶 Lambda 表达式”。
Lambda 体
lambda 表达式的 lambda 体（标准语法中的 compound-statement）可包含普通方法或函数的主体可包含的任何内容。 普通函数和 lambda 表达式的主体均可访问以下变量类型：

从封闭范围捕获变量，如前所述。

参数

本地声明变量

类数据成员（在类内部声明并且捕获 this 时）

具有静态存储持续时间的任何变量（例如，全局变量）

以下示例包含通过值显式捕获变量 n 并通过引用隐式捕获变量 m 的 lambda 表达式：

// captures_lambda_expression.cpp
// compile with: /W4 /EHsc
#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;
}

   

输出：

  5
0

            
由于变量 n 是通过值捕获的，因此在调用 lambda 表达式后，变量的值仍保持 0 不变。 mutable 规范允许在 lambda 中修改 n。
尽管 lambda 表达式只能捕获具有自动存储持续时间的变量，但你可以在 lambda 表达式的主体中使用具有静态存储持续时间的变量。 以下示例使用 generate 函数和 lambda 表达式为 vector 对象中的每个元素赋值。 lambda 表达式将修改静态变量以生成下一个元素的值。

void fillVector(vector<int>& v)
{
 // A local static variable.
 static int nextValue = 1;
 
 // The lambda expression that appears in the following call to
 // the generate function modifies and uses the local static
 // variable nextValue.
 generate(v.begin(), v.end(), [] { return nextValue++; });
 //WARNING: this is not thread-safe and is shown for illustration only
}

   

下面的代码示例使用上一示例中的函数，并添加了使用 STL 算法 generate_n 的 lambda 表达式的示例。 该 lambda 表达式将 vector 对象的元素指派给前两个元素之和。 使用了 mutable 关键字，以使 lambda 表达式的主体可以修改 lambda 表达式通过值捕获的外部变量 x 和 y 的副本。 由于 lambda 表达式通过值捕获原始变量 x 和 y，因此它们的值在 lambda 执行后仍为 1。

// compile with: /W4 /EHsc
#include 
#include 
#include 
#include 
 
using namespace std;
 
template  void print(const string& s, const C& c) {
 cout << s;
 
 for (const auto& e : c) {
 cout << e << " ";
 }
 
 cout << endl;
}
 
void fillVector(vector<int>& v)
{
 // A local static variable.
 static int nextValue = 1;
 
 // The lambda expression that appears in the following call to
 // the generate function modifies and uses the local static
 // variable nextValue.
 generate(v.begin(), v.end(), [] { return nextValue++; });
 //WARNING: this is not thread-safe and is shown for illustration only
}
 
int main()
{
 // The number of elements in the vector.
 const int elementCount = 9;
 
 // Create a vector object with each element set to 1.
 vector v(elementCount, 1);
 
 // These variables hold the previous two elements of the vector.
 int x = 1;
 int y = 1;
 
 // Sets each element in the vector to the sum of the
 // previous two elements.
 generate_n(v.begin() + 2,
 elementCount - 2,
 [=]() mutable throw() -> int { // lambda is the 3rd parameter
 // Generate current value.
 int n = x + y;
 // Update previous two values.
 x = y;
 y = n;
 return n;
 });
 print("vector v after call to generate_n() with lambda: ", v);
 
 // Print the local variables x and y.
 // The values of x and y hold their initial values because
 // they are captured by value.
 cout << "x: " << x << " y: " << y << endl;
 
 // Fill the vector with a sequence of numbers
 fillVector(v);
 print("vector v after 1st call to fillVector(): ", v);
 // Fill the vector with the next sequence of numbers
 fillVector(v);
 print("vector v after 2nd call to fillVector(): ", v);
}

   

输出：

  vector v after call to generate_n() with lambda: 1 1 2 3 5 8 13 21 34
x: 1 y: 1
vector v after 1st call to fillVector(): 1 2 3 4 5 6 7 8 9
vector v after 2nd call to fillVector(): 10 11 12 13 14 15 16 17 18

更多C++11 の新機能と組み合わせて、C++ でのラムダ式の使用法を学習します。相关文章请关注PHP中文网！