前言

在C++11新標準中，語言本身和標準庫都增加了很多新內容，本文只涉及了一些皮毛。不過我相信這些新特性當中有一些，應該成為所有C++開發(fā)者的常規(guī)裝備。本文主要介紹了C++11中l(wèi)ambda、std::function和std:bind，下面來一起看看詳細的介紹吧。

lambda 表達式

C++11中新增了lambda 表達式這一語言特性。lambda表達式可以讓我們快速和便捷的創(chuàng)建一個”函數”。

下面是lambda表達式的語法：

[ capture-list ] { body }
[ capture-list ] ( params ) { body }
[ capture-list ] ( params ) -> ret { body }
[ capture-list ] ( params ) mutable exception attribute -> ret { body }

這其中：

• - capture-list 是需要捕獲的變量列表，用逗號分隔。其詳細說明見下文。
• - params 是lambda表達式需要的參數列表，寫法和函數參數一樣，不過這里不支持默認參數。
• - ret 指明了lambda表達式的返回值。通過return語句，如果編譯器能夠推斷出返回值的類型。或者表達式沒有返回值，“-> ret”可以省略。
• - body 函數體。
• - mutable 當捕獲列表是以復制（見下文）的形式捕獲時，默認這些復制的值是const的，除非指定了mutable。
• - exception 提供了異常的說明。
• - attribute 對于attribute的描述可以參見這里：http://en.cppreference.com/w/cpp/language/attributes，這里不多說明。

下面，我們通過經典的Hello World示例來看一下lambda表達式：

auto lambda1 = [] {std::cout << "Hello, World!\n";};
lambda1();

這個lambda表達式將打印出字符串“Hello, World!”。

同時，我們將這個表達式賦值給“l(fā)ambda1”這個變量，然后像調用函數一樣，調用這個lambda表達式。

使用lambda表達式，可以讓我們省卻定義函數的麻煩，以inline的方式寫出代碼，這樣的代碼通常更簡潔。
并且，由于閱讀代碼時不用尋找函數定義，這樣的代碼也更易讀。

下面，我們來看另外一個例子。這個例子的需求是：

分兩次，打印出一個vector集合中，所有：

1. 模 5 = 0

2. 大于 20

的數字。

現假設已有這個集合的定義如下：

vector<int> numbers { 1, 2, 3, 4, 5, 10, 15, 20, 25, 35, 45, 50 };

我們最先想到的方法自然是定義兩個函數，分別按照上面的要求打印出需要的數字，它們的定義如下：

void printNumber1(vector<int>& numbers) {
 for (const int& i : numbers) {
 if (i % 5 == 0) {
 cout<<i<<endl;
 }
 }
}

void printNumber1(vector<int>& numbers) {
 for (const int& i : numbers) {
 if (i % 5 == 0) {
 cout<<i<<endl;
 }
 }
}

然后，我們在需要的地方，調用它們：

printNumber1(numbers);
printNumber2(numbers);

這里邏輯上并沒有問題，但是：

1. 這里我們必須先定義這個函數，才能使用。而這樣的函數，可能實際上我們只會使用一次。

2. 當工程大到一定程度，我們可能不記得每個函數的實現（所以函數命名很重要，原諒我這里給函數起了很含糊的名字，你在實際上工程中，請不要這樣做），為了知道每個函數的實現，我們不得不查看函數的定義，這無疑給代碼的閱讀造成了一定的麻煩。

下面，我們來看看使用lambda表達式如何改善上面說的問題。

使用lambda表達式，我們可以這樣寫：

for_each(numbers.begin(), numbers.end(), [] (int i) {
 if(i % 5 == 0) {
 cout<<i<<endl;
 }
});

for_each(numbers.begin(), numbers.end(), [] (int i) {
 if(i > 20) {
 cout<<i<<endl;
 }
});

這里，我們不用單獨定義函數，直接以inline的方式解決了問題。并且，這段代碼一氣呵成，你很直觀的看到了執(zhí)行的邏輯。

下面，我們再詳細看一下lambda表達式中的捕獲列表的語法，它可能是以下幾種情況中的一種：

• [] 不捕獲任何變量
• [&] 以引用的方式捕獲所有變量
• [=] 以復制的方式捕獲所有變量
• [=, &foo] 以引用的方式捕獲foo變量，但是以復制的方式捕獲其他變量
• [bar] 以復制的方式捕獲bar變量，不再捕獲任何其他變量
• [this] 捕獲this指針
  

下面，我們再以一個例子說明捕獲列表的用法。

這里，我們的需求是：

打印出一個vector<int>的所有數字之和

同樣的，我們先以函數的方式來解決這個問題，這個函數的定義可以是這樣的：

void printSum(vector<int>& numbers) {
 int sum = 0;
 for (const int& i : numbers) {
 sum += i;
 }
 cout<<sum<<endl;
}

然后，我們在需要的地方調用這個函數：

vector<int> numbers { 1, 2, 3, 4, 5, 10, 15, 20, 25, 35, 45, 50 };
printSum (numbers);

而假設我們用lambda表達式來寫，這樣寫就可以了：

vector<int> numbers { 1, 2, 3, 4, 5, 10, 15, 20, 25, 35, 45, 50 };
int sum = 0;
std::for_each(numbers.begin(), numbers.end(), [&sum] (const int& i) { sum += i;});
cout<<sum<<endl;

這里,我們用 [&sum]以引用的形式捕獲了sum這個變量，并且在lambda表達式中修改了這個變量。

這樣寫，是不是比定義函數的方式簡潔了很多？

對于這種，能夠捕獲其定義時上下文變量的函數，我們稱之為“閉包”，下文還將提到。

std::function

上文中，對于分兩次，打印出一個vector集合中，所有：

1. 模 5 = 0

2. 大于 20

的數字。

這個需求，我們的實現其實還不夠好。

回頭看一下printNumber1和printNumber2這兩個函數，這兩個函數大部分都是重復的：它們都需要遍歷集合，都需要做if判斷，然后打印出結果。

實際上，我們在項目中經常遇到這個的問題：

兩（多）個函數，有大部分的代碼都是一樣的，其中只有一兩行代碼有不一樣的地方。

其實，我們可以對這個不一樣的地方，再做一個抽象，把它們共通起來。

具體到這個例子就是：無論是“模 5 = 0”還是“大于 20”都是滿足“某種條件”。

而很自然的會想到，我們是否可以通過一個類似這樣的函數來做這個判斷：

bool func(int i)

然后實現兩個函數，通過函數指針的形式來完成判斷就好了。

但是，我們馬上又意識到，這兩個函數會很小，并且也是只會用一遍而已，定義一個函數又太“浪費”了。 很自然的，我們就會想lambda。但是，lambda似乎沒法轉成函數指針。。。

C++11中，提供了一個通用的描述方法，就是std::function。 std::function可以hold住任何可以通過“()”來調用的對象，包括：

• 普通函數
• 成員函數
• lambda
• std::bind（見下文）后的結果

std::function的語法是這樣：

template <class Ret, class... Args> class function<Ret(Args...)>;

例如：function<bool (int)> filter 就表達了我們前面需要的那個函數：這個函數接受一個int值作為參數，同時返回一個bool作為判斷的結果。但同時，我們可以用lambda表達式直接傳遞進去。

因此，上面的代碼可以改寫成這樣：

void printNumber(vector<int>& number, function<bool (int)> filter) {
 for (const int& i : number) {
 if (filter(i)) {
 cout<<i<<endl;
 }
 }
}

然后在需要的地方，這樣調用即可：

printNumber(numbers, [] (int i){ return i % 5 == 0;});
printNumber(numbers, [] (int i){ return i > 20;});

這種做法，是不是又簡潔了不少？

閉包

前面提到了“閉包”這個詞，這里我們來聊一下閉包。

下面是維基百度對于閉包的定義：

在計算機科學中，閉包（英語：Closure），又稱詞法閉包（Lexical Closure）或函數閉包（function closures），是引用了自由變量的函數。 這個被引用的自由變量將和這個函數一同存在，即使已經離開了創(chuàng)造它的環(huán)境也不例外。

簡單來說：閉包可以記憶住創(chuàng)建它時候的那些變量。

下面，我們再通過一個例子來說明。

現在，假設我們的需求是：獲取一個集合中最小和最大值，并在稍后的時候（可能是另外一個函數中）打印它們。 這里，我們常規(guī)的做法通常是：通過一個函數獲取集合的最大，最小值，然后保存住，最后在需要的時候訪問這兩個值，然后打印它們。
這樣做就會需要解決：如果保存和傳遞最大，最小這兩個值。

但實際上，這里我們可以考慮用閉包來實現這個功能，讓閉包把最大，最小兩個值捕獲下來，然后在需要的地方調用就可以了。

請看一下下面這段代碼：

void getMinMax(vector<int>& number, function<void ()>& printer) {
 int min = number.front();
 int max = number.front();
 for (int i : number) {
 if (i < min) {
 min = i;
 }
 if (i > max) {
 max = i;
 }
 }
 printer = [=] () {
 cout << "min:" <<min<< endl;
 cout << "max:" << max << endl;
 };
}

這里，我們通過function<void ()>& printer（如果你看不懂function，請看上文）傳遞出這個閉包。 然后，在需要的地方，這樣即可：

function<void()> printer;
getMinMax(numbers, printer);
......

printer();

這里的printer其實是我們前面從getMinMax函數出傳出的閉包，這個閉包捕獲了min和max。我們直接傳遞這個閉包給需要的地方使用，而不用傳遞裸的兩個數值，是不是優(yōu)雅的不少？

std::bind

下面，我們再改進一下需求，假設我們要

打印出vector<int>中，20<x<40范圍內的值 ，該怎么辦？

畢竟，bool isBetween(int i, int min, int max) 這個函數可沒法對應上

function<bool (int)> filter ??！參數數量就不一樣嘛。

這個時候，我們可以用 std::bind 。

std::bind的語法是這樣的：

template <class Fn, class... Args> bind (Fn&& fn, Args&&... args);
template <class Ret, class Fn, class... Args> bind (Fn&& fn, Args&&... args);

std::bind可以將調用函數時的部分參數先指定好，留下一部分在真正調用的時候確定。

（當然，你也可以直接指定全部參數，在調用時不再指定。）

這里，isBetween中，最小，最大值其實我們是確定了的，即：20和40。而不確定的，其實是真正待判斷的數字本身，那么我們就可以這么做：

std::bind(isBetween, placeholders::_1, 20, 40);

placeholders::_1 的意思是，這里是一個占位符，在調用的時候，將實際傳遞的第一個參數放到這里。

占位符的數量可以是任意多的，像這樣：

std::placeholders::_1, std::placeholders::_2, …, std::placeholders::_N。

于是乎，對于 打印出vector<int>中，20<x<40范圍內的值 這個需求，我們在不修改printNumber函數的基礎上，通過定義一個isBetween函數：

bool isBetween( int i, int min, int max) {
 return i >= min && i <= max;
}

然后，再這樣就搞定了：

function<bool(int)> filter = std::bind(isBetween, placeholders::_1, 20, 40);
printNumber(numbers, filter);

當然，你甚至可以直接把這里的兩行寫成一行。

如果你不明白這段代碼，請再看一下printNumber函數的定義：

void printNumber(vector<int>& number, function<bool (int)> filter) {
 for (const int& i : number) {
 if (filter(i)) {
  cout<<i<<endl;
 }
 }
}

這里其實調用了filter(i)這個函數對象，而這個函數對象只接受一個int值作為參數，然后返回一個bool值。

function<bool(int)> filter = std::bind(isBetween, placeholders::_1, 20, 40);

綁定之后，只缺一個int型參數，所以正好對應得上。

如果不過癮，我們再來看一個bind的例子。

我們常常需要在程序中，調用一些用戶傳過來的回調函數。而在回調函數中，用戶常常會需要記錄一些狀態(tài)，于是常常希望通過一個對象的成員函數傳給過來作為回調函數。但是在C++中，這樣做是很麻煩的一個事情。因為，回調函數的類型我們很難定義。 但是，結合std::function和std::bind，一切變得容易多了。 結合前面的例子，現在就假設我們的回調函數是需要打印集合中的最大，最小值。

這里假設我們是通過一個類來記錄和打印值的，這個類的定義是這樣的：

class Printer {
private:
 int min, max;
public:
 Printer(int x, int y) {
 min = x;
 max = y;
 }
 
 void print() {
 cout << "min:" << min << endl;
 cout << "max:" << max << endl;
 }
};

由于回調函數不需要參數，因此使用回調函數的代碼是這樣的：

void usingCallback(function<void ()> print) {
 print();
}

然后，我們可以通過下面的方法來調用print函數

Printer printer = Printer(10, 50);
function<void ()> print = bind(&Printer::print, printer);
usingCallback(print);

成員函數其實是類中的方法綁定到一個對象上，然后執(zhí)行調用。這里的代碼很直觀的表達了這個關系。

lambda表達式是如何實現的

lambda表達式是如何實現的呢？

其實是編譯器為我們了創(chuàng)建了一個類，這個類重載了()，讓我們可以像調用函數一樣使用。所以，你寫的lambda表達式和真正的實現，是這個樣子的：

而對于捕獲變量的lambda表達式來說，編譯器在創(chuàng)建類的時候，通過成員函數的形式保存了需要捕獲的變量，所以看起來是這個樣子：

似乎也沒有什么神奇的地方。但正是由于編譯器幫我們實現了細節(jié)，使我們的代碼變得優(yōu)雅和簡潔了許多。

參考資料

http://www.cprogramming.com/c++11/c++11-lambda-closures.html

http://www.drdobbs.com/cpp/lambdas-in-c11/240168241

https://en.wikipedia.org/wiki/Closure_(computer_programming)

http://www.jellythink.com/archives/771

http://en.cppreference.com/w/cpp/utility/functional/function

https://en.wikipedia.org/wiki/First-class_function

https://blog.feabhas.com/2014/03/demystifying-c-lambdas/

總結

以上就是這篇文章的全部內容了，希望本文的內容對大家學習或者工作能帶來一定的幫助，如果有疑問大家可以留言交流。謝謝大家對腳本之家的支持。

最新評論