C++11的一大亮點就是引入了Lambda表示式。利用Lambda表示式，可以方便的定義和建立匿名函式。對於C++這門語言來說來說，“Lambda表示式”或“匿名函式”這些概念聽起來好像很深奧，但很多高階語言在很早以前就已經提供了Lambda表示式的功能，如C#，Python等。今天，我們就來簡單介紹一下C++中Lambda表示式的簡單使用。

宣告Lambda表示式

Lambda表示式完整的宣告格式如下：

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

各項具體含義如下
capture list：捕獲外部變數列表
params list：形參列表
mutable指示符：用來說用是否可以修改捕獲的變數
exception：異常設定
return type：返回型別
function body：函式體
 

此外，我們還可以省略其中的某些成分來宣告“不完整”的Lambda表示式，常見的有以下幾種：

其中：

• 格式1聲明瞭const型別的表示式，這種型別的表示式不能修改捕獲列表中的值。

• 格式2省略了返回值型別，但編譯器可以根據以下規則推斷出Lambda表示式的返回型別： （1）如果function body中存在return語句，則該Lambda表示式的返回型別由return語句的返回型別確定； （2）如果function body中沒有return語句，則返回值為void型別。

• 格式3中省略了引數列表，類似普通函式中的無參函式。

  講了這麼多，我們還沒有看到Lambda表示式的廬山真面目，下面我們就舉一個例項。

#include <stdexcept>
#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;

	// Lambda表示式 [capture list] (params list) mutable exception-> return type { function body }
	sort(lbvec.begin(), lbvec.end(), [](int a, int b) -> bool { return a < b; });   
	cout << "lambda expression:" << endl;
	for (int it : lbvec)
		cout << it << ' ';
}
 

在C++11之前，我們使用STL的sort函式，需要提供一個謂詞函式。如果使用C++11的Lambda表示式，我們只需要傳入一個匿名函式即可，方便簡潔，而且程式碼的可讀性也比舊式的做法好多了。

下面，我們就重點介紹一下Lambda表示式各項的具體用法。

捕獲外部變數

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);
	return 0;
}

上面這個例子先聲明瞭一個整型變數a，然後再建立Lambda表示式，該表示式“捕獲”了a變數，這樣在Lambda表示式函式體中就可以獲得該變數的值。

類似引數傳遞方式（值傳遞、引入傳遞、指標傳遞），在Lambda表示式中，外部變數的捕獲方式也有值捕獲、引用捕獲、隱式捕獲。

1、值捕獲

值捕獲和引數傳遞中的值傳遞類似，被捕獲的變數的值在Lambda表示式建立時通過值拷貝的方式傳入，因此隨後對該變數的修改不會影響影響Lambda表示式中的值。

示例如下：

#include <iostream>
using namespace std;

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

	return 0;
}

這裡需要注意的是，如果以傳值方式捕獲外部變數，則在Lambda表示式函式體中不能修改該外部變數的值。

2、引用捕獲

使用引用捕獲一個外部變數，只需要在捕獲列表變數前面加上一個引用說明符&。如下：

#include <iostream>
using namespace std;

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

	return 0;
}

從示例中可以看出，引用捕獲的變數使用的實際上就是該引用所繫結的物件。

3、隱式捕獲

上面的值捕獲和引用捕獲都需要我們在捕獲列表中顯示列出Lambda表示式中使用的外部變數。除此之外，我們還可以讓編譯器根據函式體中的程式碼來推斷需要捕獲哪些變數，這種方式稱之為隱式捕獲。隱式捕獲有兩種方式，分別是[=]和[&]。[=]表示以值捕獲的方式捕獲外部變數，[&]表示以引用捕獲的方式捕獲外部變數。

隱式值捕獲示例：

#include <iostream>
using namespace std;

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

	return 0;
}

隱式引用捕獲示例：

#include <iostream>
using namespace std;

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

	return 0;
}

4、混合方式

上面的例子，要麼是值捕獲，要麼是引用捕獲，Lambda表示式還支援混合的方式捕獲外部變數，這種方式主要是以上幾種捕獲方式的組合使用。

到這裡，我們來總結一下：C++11中的Lambda表示式捕獲外部變數主要有以下形式：

修改捕獲變數

前面我們提到過，在Lambda表示式中，如果以傳值方式捕獲外部變數，則函式體中不能修改該外部變數，否則會引發編譯錯誤。那麼有沒有辦法可以修改值捕獲的外部變數呢？這是就需要使用mutable關鍵字，該關鍵字用以說明表示式體內的程式碼可以修改值捕獲的變數，示例：

#include <iostream>
using namespace std;

int main()
{
	int a = 123;
	auto f = [a]()mutable { cout << ++a; }; // 不會報錯
	cout << a << endl; // 輸出：123
	f(); // 輸出：124
	return 0;
}

Lambda表示式的引數

Lambda表示式的引數和普通函式的引數類似，那麼這裡為什麼還要拿出來說一下呢？原因是在Lambda表示式中傳遞引數還有一些限制，主要有以下幾點：

1. 引數列表中不能有預設引數
2. 不支援可變引數
3. 所有引數必須有引數名

常用舉例：

#include <iostream>
using namespace std;

int main()
{
	int m = [](int x) { return [](int y) { return y * 2; }(x)+6; }(5);
	std::cout << "m:" << m << std::endl;//輸出m:16

	std::cout << "n:" << [](int x, int y) { return x + y; }(5, 4) << std::endl;//輸出n:9

	auto 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; };

	return 0;
}
//有部分存在疑問