詳解C++11中的lambda匿名函數

2022-11-28 22:00:16

1. lambda匿名函數的定義

[capture](parameters)mutable ->return-type{statement}

引數說明：

[capture]：捕捉列表，[] 是lambda引出符，編譯器根據該引出符判斷接下來的程式碼是否是lambda函數。捕捉列表用於捕捉父域中的變數以供lambda函數使用，捕捉列表可以由多個項組成，用","分割。[var]表示以值傳遞方式捕捉父域中的變數var，[=]表示以值傳遞方式捕捉父域中的所有變數（包括this），[&var]表示以參照傳遞方式捕捉父域中的變數var，[&]表示以參照傳遞方式捕捉父域中的所有變數（包括this）,[this]表示以值傳遞方式捕捉當前的this指標。
(parameters)：參數列，與普通函數的參數列一致，如果不需要引數傳遞，則可以連同括號()一起省略。
mutable：mutable修飾符，預設情況下，lambda函數總是一個const函數，mutable可以取消其常數性。在使用該修飾符時，參數列不可省略（即使引數為空）。
->return-type：返回型別，用追蹤返回型別形式宣告函數的返回型別，不需要返回值的時候可以連同符號->一起省略。在返回型別明確的情況下，也可以省略該部分，讓編譯器對返回型別進行推導。
{statement}：函數體，內容與普通函數一樣，不過除了可以使用引數之外，還可以使用所有捕獲的變數。

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

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

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

最簡單的lambda匿名函數

[]{}

此 lambda 匿名函數未引入任何外部變數（[] 內為空），也沒有傳遞任何引數，沒有指定 mutable、noexcept 等關鍵字，沒有返回值和函數體。所以，這是一個沒有任何功能的 lambda 匿名函數。

2. lambda匿名函數的使用

2.1 lambda匿名函數的定義和使用

#include <iostream>
#include <algorithm>
using namespace std;

int main()
{
    int num[4] = { 4, 2, 3, 1 };
    // 對陣列 num 中的元素進行升序排序
    sort(num, num + 4, [=](int x, int y) -> bool { return x < y; });
    for (int n : num) {
        cout << n << " ";
    }
    return 0;
}

以上程式通過呼叫 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 };
    // 對陣列 num 中的元素進行升序排序
    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); // 輸出：10 20
    return 0;
}

可以看到，程式中使用 auto 關鍵字為 lambda 匿名函數設定了一個函數名，由此我們即可在作用域內呼叫該函數。

2.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 匿名函數的基礎上修改外部變數的值，可以藉助 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 拷貝的那一份的值，真正外部變數的值並不會發生改變。

2.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 匿名函數的函數體中允許發生任何型別的異常。

到此這篇關於C++11中的lambda匿名函數的文章就介紹到這了,更多相關C++11 lambda匿名函數內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com！