C++11的一大亮點就是引入了Lambda表達(dá)式。利用Lambda表達(dá)式，可以方便的定義和創(chuàng)建匿名函數(shù)。對于C++這門語言來說來說，“Lambda表達(dá)式”或“匿名函數(shù)”這些概念聽起來好像很深奧，但很多高級語言在很早以前就已經(jīng)提供了Lambda表達(dá)式的功能，如C#，Python等。今天，我們就來簡單介紹一下C++中Lambda表達(dá)式的簡單使用。

聲明Lambda表達(dá)式
Lambda表達(dá)式完整的聲明格式如下：

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

各項具體含義如下
capture list：捕獲外部變量列表
params list：形參列表
mutable指示符：用來說用是否可以修改捕獲的變量
exception：異常設(shè)定，例如throw()
return type：返回類型
function body：函數(shù)體
此外，我們還可以省略其中的某些成分來聲明“不完整”的Lambda表達(dá)式，常見的有以下幾種：

1 [capture list] (params list) -> return type {function body} 2 [capture list] (params list) {function body} 3 [capture list] {function body} 其中:

1.格式1聲明了const類型的表達(dá)式，這種類型的表達(dá)式不能修改捕獲列表中的值。

2.格式2省略了返回值類型，但編譯器可以根據(jù)以下規(guī)則推斷出Lambda表達(dá)式的返回類型：?

（1）如果function body中存在return語句，則該Lambda表達(dá)式的返回類型由return語句的返回類型確定；

（2）如果function body中沒有return語句，則返回值為void類型。

3.格式3中省略了參數(shù)列表，類似普通函數(shù)中的無參函數(shù)。

講了這么多，我們還沒有看到Lambda表達(dá)式的廬山真面目，下面我們就舉一個實例。

#include#include#includeusing?namespace?std;

bool?cmp(int?a,?int?b)
{
????return??a?<?b;
}

int?main()
{
????vectormyvec{?3,?2,?5,?7,?3,?2?};
????vectorlbvec(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表達(dá)式
????cout?<<?"lambda?expression:"?<<?endl;
????for?(int?it?:?lbvec)
????????cout?<<?it?<<?'?';
}

在C++11之前，我們使用STL的sort函數(shù)，需要提供一個謂詞函數(shù)。如果使用C++11的Lambda表達(dá)式，我們只需要傳入一個匿名函數(shù)即可，方便簡潔，而且代碼的可讀性也比舊式的做法好多了。
下面，我們就重點介紹一下Lambda表達(dá)式各項的具體用法。
捕獲外部變量
Lambda表達(dá)式可以使用其可見范圍內(nèi)的外部變量，但必須明確聲明（明確聲明哪些外部變量可以被該Lambda表達(dá)式使用）。那么，在哪里指定這些外部變量呢？Lambda表達(dá)式通過在最前面的方括號[]來明確指明其內(nèi)部可以訪問的外部變量，這一過程也稱過Lambda表達(dá)式“捕獲”了外部變量。
我們通過一個例子來直觀地說明一下：

#includeusing?namespace?std;

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

????//或通過“函數(shù)體”后面的‘()’傳入?yún)?shù)
????auto?x?=?[](int?a){cout?<<?a?<<?endl;};
????x(123);
}

上面這個例子先聲明了一個整型變量a，然后再創(chuàng)建Lambda表達(dá)式，該表達(dá)式“捕獲”了a變量，這樣在Lambda表達(dá)式函數(shù)體中就可以獲得該變量的值。
類似參數(shù)傳遞方式（值傳遞、引用傳遞、指針傳遞），在Lambda表達(dá)式中，外部變量的捕獲方式也有值捕獲、引用捕獲、隱式捕獲。
1、值捕獲
值捕獲和參數(shù)傳遞中的值傳遞類似，被捕獲的變量的值在Lambda表達(dá)式創(chuàng)建時通過值拷貝的方式傳入，因此隨后對該變量的修改不會影響影響Lambda表達(dá)式中的值。
示例如下：

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

這里需要注意的是，如果以傳值方式捕獲外部變量，則在Lambda表達(dá)式函數(shù)體中不能修改該外部變量的值。
2、引用捕獲
使用引用捕獲一個外部變量，只需要在捕獲列表變量前面加上一個引用說明符&。如下：

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

從示例中可以看出，引用捕獲的變量使用的實際上就是該引用所綁定的對象。
3、隱式捕獲
上面的值捕獲和引用捕獲都需要我們在捕獲列表中顯示列出Lambda表達(dá)式中使用的外部變量。除此之外，我們還可以讓編譯器根據(jù)函數(shù)體中的代碼來推斷需要捕獲哪些變量，這種方式稱之為隱式捕獲。隱式捕獲有兩種方式，分別是[=]和[&]。[=]表示以值捕獲的方式捕獲外部變量，[&]表示以引用捕獲的方式捕獲外部變量。
隱式值捕獲示例：

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
}

4、混合方式
上面的例子，要么是值捕獲，要么是引用捕獲，Lambda表達(dá)式還支持混合的方式捕獲外部變量，這種方式主要是以上幾種捕獲方式的組合使用。
到這里，我們來總結(jié)一下：C++11中的Lambda表達(dá)式捕獲外部變量主要有以下形式：[] 不捕獲任何外部變量 [變量名, …] 默認(rèn)以值得形式捕獲指定的多個外部變量（用逗號分隔），如果引用捕獲，需要顯示聲明（使用&說明符） [this] 以值的形式捕獲this指針 [=] 以值的形式捕獲所有外部變量 [&] 以引用形式捕獲所有外部變量 [=, &x] 變量x以引用形式捕獲，其余變量以傳值形式捕獲 [&, x] 變量x以值的形式捕獲，其余變量以引用形式捕獲

修改捕獲變量
前面我們提到過，在Lambda表達(dá)式中，如果以傳值方式捕獲外部變量，則函數(shù)體中不能修改該外部變量，否則會引發(fā)編譯錯誤。那么有沒有辦法可以修改值捕獲的外部變量呢？這是就需要使用mutable關(guān)鍵字，該關(guān)鍵字用以說明表達(dá)式體內(nèi)的代碼可以修改值捕獲的變量，示例：

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

Lambda表達(dá)式的參數(shù)
Lambda表達(dá)式的參數(shù)和普通函數(shù)的參數(shù)類似，那么這里為什么還要拿出來說一下呢？原因是在Lambda表達(dá)式中傳遞參數(shù)還有一些限制，主要有以下幾點：
1.參數(shù)列表中不能有默認(rèn)參數(shù)
2.不支持可變參數(shù)
3.所有參數(shù)必須有參數(shù)名
常用舉例：

#include#includeusing?namespace?std;

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

	auto?gFunc?=?[](int?x)?->?function{?return?[=](int?y)?{?return?x?+?y;?};?};
	auto?lFunc?=?gFunc(4);
	std::cout?<<?lFunc(5)?<<?std::endl;//輸出9

	auto?hFunc?=?[](const?function&?f,?int?z)?{?return?f(z)?+?1;?};
	auto?r?=?hFunc(gFunc(7),?8);
	std::cout?<<?r?<<?std::endl;//輸出16

	int?a?=?111,?b?=?222;
	auto?func1?=?[=,?&b]()mutable?{?a?=?22;?b?=?333;?std::cout?<<?a?<<?b?<<?std::endl;?};
	func1();//輸出22333
	std::cout?<<?a??<<?b?<<?std::endl;//輸出111333

	a?=?333;
	auto?func2?=?[=,?&a]?{?a?=?444;?std::cout?<<?a?<<?b?<<?std::endl;?};
	func2();//輸出444333

	std::functionf_display_42?=?[](int?x)?{?std::cout<<?x?<<?std::endl;?};
	f_display_42(44);//輸出44

	system("pause");
	return?0;
}