C++ 11 Lambda表達式

C++11的一大亮點就是引入了Lambda表達式。利用Lambda表達式，能夠方便的定義和建立匿名函數。對於C++這門語言來講來講，「Lambda表達式」或「匿名函數」這些概念聽起來好像很深奧，但不少高級語言在很早之前就已經提供了Lambda表達式的功能，如C#，Python等。今天，咱們就來簡單介紹一下C++中Lambda表達式的簡單使用。

聲明Lambda表達式

Lambda表達式完整的聲明格式以下：

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

各項具體含義以下

1. capture list：捕獲外部變量列表
2. params list：形參列表
3. mutable指示符：用來講用是否能夠修改捕獲的變量
4. exception：異常設定
5. return type：返回類型
6. function body：函數體

此外，咱們還能夠省略其中的某些成分來聲明「不完整」的Lambda表達式，常見的有如下幾種：

序號	格式
1	[capture list] (params list) -> return type {function body}
2	[capture list] (params list) {function body}
3	[capture list] {function body}

其中：

• 格式1聲明瞭const類型的表達式，這種類型的表達式不能修改捕獲列表中的值。
• 格式2省略了返回值類型，但編譯器能夠根據如下規則推斷出Lambda表達式的返回類型： （1）：若是function body中存在return語句，則該Lambda表達式的返回類型由return語句的返回類型肯定； （2）：若是function body中沒有return語句，則返回值爲void類型。

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

  講了這麼多，咱們尚未看到Lambda表達式的廬山真面目，下面咱們就舉一個實例。

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

    sort(lbvec.begin(), lbvec.end(), [](int a, int b) -> bool { return a < b; });   // Lambda表達式
    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); 
}

上面這個例子先聲明瞭一個整型變量a，而後再建立Lambda表達式，該表達式「捕獲」了a變量，這樣在Lambda表達式函數體中就能夠得到該變量的值。

相似參數傳遞方式（值傳遞、引入傳遞、指針傳遞），在Lambda表達式中，外部變量的捕獲方式也有值捕獲、引用捕獲、隱式捕獲。

一、值捕獲

值捕獲和參數傳遞中的值傳遞相似，被捕獲的變量的值在Lambda表達式建立時經過值拷貝的方式傳入，所以隨後對該變量的修改不會影響影響Lambda表達式中的值。

示例以下：

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

這裏須要注意的是，若是以傳值方式捕獲外部變量，則在Lambda表達式函數體中不能修改該外部變量的值。

二、引用捕獲

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

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

從示例中能夠看出，引用捕獲的變量使用的實際上就是該引用所綁定的對象。

三、隱式捕獲

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

隱式值捕獲示例：

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
}

四、混合方式

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

到這裏，咱們來總結一下：C++11中的Lambda表達式捕獲外部變量主要有如下形式：

捕獲形式	說明
[]	不捕獲任何外部變量
[變量名, …]	默認以值得形式捕獲指定的多個外部變量（用逗號分隔），若是引用捕獲，須要顯示聲明（使用&說明符）
[this]	以值的形式捕獲this指針
[=]	以值的形式捕獲全部外部變量
[&]	以引用形式捕獲全部外部變量
[=, &x]	變量x以引用形式捕獲，其他變量以傳值形式捕獲
[&, x]	變量x以值的形式捕獲，其他變量以引用形式捕獲

修改捕獲變量

前面咱們提到過，在Lambda表達式中，若是以傳值方式捕獲外部變量，則函數體中不能修改該外部變量，不然會引起編譯錯誤。那麼有沒有辦法能夠修改值捕獲的外部變量呢？這是就須要使用mutable關鍵字，該關鍵字用以說明表達式體內的代碼能夠修改值捕獲的變量，示例：

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

Lambda表達式的參數

Lambda表達式的參數和普通函數的參數相似，那麼這裏爲何還要拿出來講一下呢？緣由是在Lambda表達式中傳遞參數還有一些限制，主要有如下幾點：

1. 參數列表中不能有默認參數
2. 不支持可變參數
3. 全部參數必須有參數名

經常使用舉例：

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

    　　

　　　　 std::function<void(int x)> f_display_42 = [](int x) { print_num(x); };
	f_display_42(44);

　　}