#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
 );
}

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

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
}

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

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

參數(shù)列表
除了捕獲變量，lambda 還可接受輸入參數(shù)。 參數(shù)列表（在標準語法中稱為 lambda 聲明符）是可選的，它在大多數(shù)方面類似于函數(shù)的參數(shù)列表。

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

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

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

返回類型
將自動推導 lambda 表達式的返回類型。 無需使用 auto 關鍵字，除非指定尾隨返回類型。 trailing-return-type 類似于普通方法或函數(shù)的返回類型部分。 但是，返回類型必須跟在參數(shù)列表的后面，你必須在返回類型前面包含 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

// 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

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
}

// compile with: /W4 /EHsc
#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)
{
 // 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<int> 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