C++11中lambda、std::function和std:bind詳解。本站提示廣大學習愛好者：（C++11中lambda、std::function和std:bind詳解）文章只能為提供參考，不一定能成為您想要的結果。以下是C++11中lambda、std::function和std:bind詳解正文
前言
在C++11新規范中，言語自身和規范庫都添加了很多新內容，本文只觸及了一些皮毛。不過我置信這些新特性當中有一些，應該成為一切C++開發者的慣例配備。本文次要引見了C++11中lambda、std::function和std:bind，上面來一同看看詳細的引見吧。
lambda 表達式
C++11中新增了lambda 表達式這一言語特性。lambda表達式可以讓我們疾速和便捷的創立一個”函數”。
上面是lambda表達式的語法：
[ capture-list ] { body }
[ capture-list ] ( params ) { body }
[ capture-list ] ( params ) -> ret { body }
[ capture-list ] ( params ) mutable exception attribute -> ret { body }
這其中：
上面，我們經過經典的Hello World示例來看一下lambda表達式：
auto lambda1 = [] {std::cout << "Hello, World!\n";};
lambda1();
這個lambda表達式將打印出字符串“Hello, World!”。
同時，我們將這個表達式賦值給“lambda1”這個變量，然後像調用函數一樣，調用這個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的方式處理了問題。並且，這段代碼一氣呵成，你很直觀的看到了執行的邏輯。
上面，我們再詳細看一下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），是援用了自在變量的函數。 這個被援用的自在變量將和這個函數一同存在，即便曾經分開了發明它的環境也不例外。
復雜來說：閉包可以記憶住創立它時分的那些變量。
上面，我們再經過一個例子來闡明。
如今，假定我們的需求是：獲取一個集合中最小和最大值，並在稍後的時分（能夠是另外一個函數中）打印它們。 這裡，我們慣例的做法通常是：經過一個函數獲取集合的最大，最小值，然後保管住，最後在需求的時分訪問這兩個值，然後打印它們。
這樣做就會需求處理：假如保管和傳遞最大，最小這兩個值。
但實踐上，這裡我們可以思索用閉包來完成這個功用，讓閉包把最大，最小兩個值捕捉上去，然後在需求的中央調用就可以了。
請看一下上面這段代碼：
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。我們直接傳遞這個閉包給需求的中央運用，而不必傳遞裸的兩個數值，是不是優雅的不少？
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的例子。
我們經常需求在順序中，調用一些用戶傳過去的回調函數。而在回調函數中，用戶經常會需求記載一些形態，於是經常希望經過一個對象的成員函數傳給過去作為回調函數。但是在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);
成員函數其實是類中的辦法綁定到一個對象上，然後執行調用。這裡的代碼很直觀的表達了這個關系。
lambda表達式是如何完成的
lambda表達式是如何完成的呢？
其實是編譯器為我們了創立了一個類，這個類重載了()，讓我們可以像調用函數一樣運用。所以，你寫的lambda表達式和真正的完成，是這個樣子的：
而關於捕捉變量的lambda表達式來說，編譯器在創立類的時分，經過成員函數的方式保管了需求捕捉的變量，所以看起來是這個樣子：
似乎也沒有什麼神奇的中央。但正是由於編譯器幫我們完成了細節，使我們的代碼變得優雅和簡約了許多。
參考材料
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/
總結
以上就是這篇文章的全部內容了，希望本文的內容對大家學習或許任務能帶來一定的協助，假如有疑問大家可以留言交流。謝謝大家對的支持。
