C++11 lambda匿名函數用法詳解

lambda 源自希臘字母表中第 11 位的 λ，在計算機科學領域，它則是被用來表示一種匿名函數。所謂匿名函數，簡單地理解就是沒有名稱的函數，又常被稱爲 lambda 函數或者 lambda 表達式。

繼 Python、Java、C#、PHP 等衆多高級編程語言都支持 lambda 匿名函數後，C++11 標準終於引入了 lambda，本節將帶領大家系統地學習 lambda 表達式的具體用法。

lambda匿名函數的定義

定義一個 lambda 匿名函數很簡單，可以套用如下的語法格式：[外部變量訪問方式說明符] (參數) mutable noexcept/throw() -> 返回值類型
{
   函數體;
};


其中各部分的含義分別爲：

1) [外部變量方位方式說明符]
[ ] 方括號用於向編譯器表明當前是一個 lambda 表達式，其不能被省略。在方括號內部，可以註明當前 lambda 函數的函數體中可以使用哪些“外部變量”。

所謂外部變量，指的是和當前 lambda 表達式位於同一作用域內的所有局部變量。

2) (參數)
和普通函數的定義一樣，lambda 匿名函數也可以接收外部傳遞的多個參數。和普通函數不同的是，如果不需要傳遞參數，可以連同 () 小括號一起省略；

3) mutable
此關鍵字可以省略，如果使用則之前的 () 小括號將不能省略（參數個數可以爲 0）。默認情況下，對於以值傳遞方式引入的外部變量，不允許在 lambda 表達式內部修改它們的值（可以理解爲這部分變量都是 const 常量）。而如果想修改它們，就必須使用 mutable 關鍵字。

注意，對於以值傳遞方式引入的外部變量，lambda 表達式修改的是拷貝的那一份，並不會修改真正的外部變量；

4) noexcept/throw()
可以省略，如果使用，在之前的 () 小括號將不能省略（參數個數可以爲 0）。默認情況下，lambda 函數的函數體中可以拋出任何類型的異常。而標註 noexcept 關鍵字，則表示函數體內不會拋出任何異常；使用 throw() 可以指定 lambda 函數內部可以拋出的異常類型。

值得一提的是，如果 lambda 函數標有 noexcept 而函數體內拋出了異常，又或者使用 throw() 限定了異常類型而函數體內拋出了非指定類型的異常，這些異常無法使用 try-catch 捕獲，會導致程序執行失敗（本節後續會給出實例）。

5) -> 返回值類型
指明 lambda 匿名函數的返回值類型。值得一提的是，如果 lambda 函數體內只有一個 return 語句，或者該函數返回 void，則編譯器可以自行推斷出返回值類型，此情況下可以直接省略













-> 返回值類型。

6) 函數體
和普通函數一樣，lambda 匿名函數包含的內部代碼都放置在函數體中。該函數體內除了可以使用指定傳遞進來的參數之外，還可以使用指定的外部變量以及全局範圍內的所有全局變量。

需要注意的是，外部變量會受到以值傳遞還是以引用傳遞方式引入的影響，而全局變量則不會。換句話說，在 lambda 表達式內可以使用任意一個全局變量，必要時還可以直接修改它們的值。

其中，紅色標識的參數是定義 lambda 表達式時必須寫的，而綠色標識的參數可以省略。

比如，如下就定義了一個最簡單的 lambda 匿名函數：[]{}顯然，此 lambda 匿名函數未引入任何外部變量（[] 內爲空），也沒有傳遞任何參數，沒有指定 mutable、noexcept 等關鍵字，沒有返回值和函數體。所以，這是一個沒有任何功能的 lambda 匿名函數。

lambda匿名函數中的[外部變量]

對於 lambda 匿名函數的使用，令多數初學者感到困惑的就是 [外部變量] 的使用。其實很簡單，無非表 1 所示的這幾種編寫格式。

表 1 [外部變量]的定義方式

外部變量格式	功能
[]	空方括號表示當前 lambda 匿名函數中不導入任何外部變量。
[=]	只有一個 = 等號，表示以值傳遞的方式導入所有外部變量；
[&]	只有一個 & 符號，表示以引用傳遞的方式導入所有外部變量；
[val1,val2,...]	表示以值傳遞的方式導入 val1、val2 等指定的外部變量，同時多個變量之間沒有先後次序；
[&val1,&val2,...]	表示以引用傳遞的方式導入 val1、val2等指定的外部變量，多個變量之間沒有前後次序；
[val,&val2,...]	以上 2 種方式還可以混合使用，變量之間沒有前後次序。
[=,&val1,...]	表示除 val1 以引用傳遞的方式導入外，其它外部變量都以值傳遞的方式導入。
[this]	表示以值傳遞的方式導入當前的 this 指針。

 注意，單個外部變量不允許以相同的傳遞方式導入多次。例如 [=，val1] 中，val1 先後被以值傳遞的方式導入了 2 次，這是非法的。

【例 1】lambda 匿名函數的定義和使用。

#include <iostream>#include <algorithm>using namespace std;int main(){    int num[4] = {4, 2, 3, 1};    //對 a 數組中的元素進行排序    sort(num, num+4, [=](int x, int y) -> bool{ return x < y; } );    for(int n : num){        cout << n << " ";    }    return 0;}

程序執行結果爲：
1 2 3 4 程序第 9 行通過調用 sort() 函數實現了對 num 數組中元素的升序排序，其中就用到了 lambda 匿名函數。而如果使用普通函數，需以如下代碼實現：

#include <iostream>#include <algorithm>using namespace std;//自定義的升序排序規則bool sort_up(int x,int y){return  x < y;}int main(){    int num[4] = {4, 2, 3, 1};    //對 a 數組中的元素進行排序    sort(num, num+4, sort_up);    for(int n : num){        cout << n << " ";    }    return 0;}

此程序中 sort_up() 函數的功能和上一個程序中的 lambda 匿名函數完全相同。 顯然在類似的場景中，使用 lambda 匿名函數更有優勢。

除此之外，雖然 lambda 匿名函數沒有函數名稱，但我們仍可以爲其手動設置一個名稱，比如：

#include <iostream>using namespace std;int main(){    //display 即爲 lambda 匿名函數的函數名    auto display = [](int a,int b) -> void{cout << a << " " << b;};    //調用 lambda 函數    display(10,20);    return 0;}

程序執行結果爲：
10 20 可以看到，程序中使用 auto 關鍵字爲 lambda 匿名函數設定了一個函數名，由此我們即可在作用域內調用該函數。

【例 2】值傳遞和引用傳遞的區別

#include <iostream>using namespace std;//全局變量int all_num = 0;int main(){    //局部變量    int num_1 = 1;    int num_2 = 2;    int num_3 = 3;    cout << "lambda1:\n";    auto lambda1 = [=]{        //全局變量可以訪問甚至修改        all_num = 10;        //函數體內只能使用外部變量，而無法對它們進行修改        cout << num_1 << " "             << num_2 << " "             << num_3 << endl;    };    lambda1();    cout << all_num <<endl;    cout << "lambda2:\n";    auto lambda2 = [&]{        all_num = 100;        num_1 = 10;        num_2 = 20;        num_3 = 30;        cout << num_1 << " "             << num_2 << " "             << num_3 << endl;    };    lambda2();    cout << all_num << endl;    return 0;}

程序執行結果爲：
lambda1:
1 2 3
10
lambda2:
10 20 30
100




可以看到，在創建 lambda1 和 lambda2 匿名函數的作用域中，有 num_1、num_2 和 num_3 這 3 個局部變量，另外還有 all_num 全局變量。

其中，lambda1 匿名函數是以 [=] 值傳遞的方式導入的局部變量，這意味着默認情況下，此函數內部無法修改這 3 個局部變量的值，但全局變量 all_num 除外。相對地，lambda2 匿名函數以 [&] 引用傳遞的方式導入這 3 個局部變量，因此在該函數的內部不就可以訪問這 3 個局部變量，還可以任意修改它們。同樣，也可以訪問甚至修改全局變量。

感興趣的讀者，可自行嘗試在 lambda1 匿名函數中修改 num_1、num_2 或者 num_3 的值，觀察編譯器的報錯信息。

當然，如果我們想在 lambda1 匿名函數的基礎上修改外部變量的值，可以藉助 mutable 關鍵字，例如：

auto lambda1 = [=]() mutable{    num_1 = 10;    num_2 = 20;    num_3 = 30;    //函數體內只能使用外部變量，而無法對它們進行修改    cout << num_1 << " "         << num_2 << " "         << num_3 << endl;};

由此，就可以在 lambda1 匿名函數中修改外部變量的值。 但需要注意的是，這裏修改的僅是 num_1、num_2、num_3 拷貝的那一份的值，真正外部變量的值並不會發生改變。

【例 3】執行拋出異常類型

#include <iostream>using namespace std;int main(){    auto except = []()throw(int) {        throw 10;    };    try {        except();    }    catch (int) {        cout << "捕獲到了整形異常";    }    return 0;}

程序執行結果爲：
捕獲到了整形異常 可以看到，except 匿名數組中指定函數體中可以拋出整形異常，因此當函數體中真正發生整形異常時，可以藉助 try-catch 塊成功捕獲並處理。

在此基礎上，在看一下反例：

#include <iostream>using namespace std;int main(){    auto except1 = []()noexcept{        throw 100;    };    auto except2 = []()throw(char){        throw 10;    };    try{        except1();        except2();    }catch(int){        cout << "捕獲到了整形異常"<< endl;    }    return 0;}

此程序運行會直接崩潰，原因很簡單，except1 匿名函數指定了函數體中不發生任何異常，但函數體中卻發生了整形異常； except2 匿名函數指定函數體可能會發生字符異常，但函數體中卻發生了整形異常。 由於指定異常類型和真正發生的異常類型不匹配，導致 try-catch 無法捕獲，最終程序運行崩潰。

如果不使用 noexcept 或者 throw()，則 lambda 匿名函數的函數體中允許發生任何類型的異常。