[轉] c++11 bind和function

[轉自 https://blog.csdn.net/fjb2080/article/details/7527715]

[轉自 https://www.cnblogs.com/lidabo/p/7266885.html]

[轉自 https://www.jianshu.com/p/f191e88dcc80]

1.std::bind

標準庫函數bind()和function()定義於頭文件中（該頭文件還包括許多其餘函數對象），用於處理函數及函數參數。bind()接受一個函數（或者函數對象，或者任何你能夠經過」(…)」符號調用的事物），生成一個其有某一個或多個函數參數被「綁定」或從新組織的函數對象。（譯註：顧名思義，bind()函數的意義就像它的函數名同樣，是用來綁定函數調用的某些參數的。）例如：

1 #include<iostream>
2 using namespace std;
3 int  main()
4 {
5         auto func = [] () {cout << "hello world"; };
6           
7         func();//now call the function
8 }        

參數的綁定一般稱爲」Currying」（譯註：Currying—「烹製咖喱燒菜」，此處意指對函數或函數對象進行加工修飾操做）, 「_1″是一個佔位符對象，用於表示當函數f經過函數ff進行調用時，函數ff的第一個參數在函數f的參數列表中的位置。第一個參數稱爲」_1″, 第二個參數爲」_2″，依此類推。例如：

1 int f(int, char, double);
2 auto frev =bind(f, _3, _2, _1); //翻轉參數順序
3 int x = frev(1.2, 'c',7); //f(7, 'c'.1.2);

此處，auto關鍵字節約了咱們去推斷bind返回的結果類型的工做。

咱們沒法使用bind()綁定一個重載函數的參數，咱們必須顯式地指出須要綁定的重載函數的版本：

1 int g(int);
2 double g(double);
3 
4 auto g1= bind(g,_1); //錯誤，調用哪個g（）？
5 //正確,可是至關醜陋
6 auto g2=bind( ( double(*) (double))g, _1);

bind()有兩種版本：一個如上所述，另外一個則是「歷史遺留」的版本：你能夠顯式地描述返回類型。例如：

1         auto f2 = bind<int> (f, 7, ‘c’, _1);      // 顯式返回類型
2 
3         int x = f2(1.2);                    // f(7, ‘c’, 1.2);

第二種形式的存在是必要的，而且由於第一個版本（(?) 「and for a user simplest 「，此處請參考原文)）沒法在C++98中實現。因此第二個版本已經被普遍使用。

 

1.1 std::bind綁定普通函數

double my_divide (double x, double y) {return x/y;} auto fn_half = std::bind (my_divide,_1,2); std::cout << fn_half(10) << '\n'; // 5 

• bind的第一個參數是函數名，普通函數作實參時，會隱式轉換成函數指針。所以std::bind (my_divide,_1,2)等價於std::bind (&my_divide,_1,2)；
• _1表示佔位符，位於<functional>中，std::placeholders::_1；

1.2 std::bind綁定一個成員函數

struct Foo { void print_sum(int n1, int n2) { std::cout << n1+n2 << '\n'; } int data = 10; }; int main() { Foo foo; auto f = std::bind(&Foo::print_sum, &foo, 95, std::placeholders::_1); f(5); // 100 } 

• bind綁定類成員函數時，第一個參數表示對象的成員函數的指針，第二個參數表示對象的地址。
• 必須顯示的指定&Foo::print_sum，由於編譯器不會將對象的成員函數隱式轉換成函數指針，因此必須在Foo::print_sum前添加&；
• 使用對象成員函數的指針時，必需要知道該指針屬於哪一個對象，所以第二個參數爲對象的地址 &foo；

1.3 綁定一個引用參數

默認狀況下，bind的那些不是佔位符的參數被拷貝到bind返回的可調用對象中。可是，與lambda相似，有時對有些綁定的參數但願以引用的方式傳遞，或是要綁定參數的類型沒法拷貝。

#include <iostream> #include <functional> #include <vector> #include <algorithm> #include <sstream> using namespace std::placeholders; using namespace std; ostream & print(ostream &os, const string& s, char c) { os << s << c; return os; } int main() { vector<string> words{"helo", "world", "this", "is", "C++11"}; ostringstream os; char c = ' '; for_each(words.begin(), words.end(), [&os, c](const string & s){os << s << c;} ); cout << os.str() << endl; ostringstream os1; // ostream不能拷貝，若但願傳遞給bind一個對象， // 而不拷貝它，就必須使用標準庫提供的ref函數 for_each(words.begin(), words.end(), bind(print, ref(os1), _1, c)); cout << os1.str() << endl; } 

1.4. 指向成員函數的指針

經過下面的例子，熟悉一下指向成員函數的指針的定義方法。

#include <iostream> struct Foo { int value; void f() { std::cout << "f(" << this->value << ")\n"; } void g() { std::cout << "g(" << this->value << ")\n"; } }; void apply(Foo* foo1, Foo* foo2, void (Foo::*fun)()) { (foo1->*fun)(); // call fun on the object foo1 (foo2->*fun)(); // call fun on the object foo2 } int main() { Foo foo1{1}; Foo foo2{2}; apply(&foo1, &foo2, &Foo::f); apply(&foo1, &foo2, &Foo::g); } 

• 成員函數指針的定義：void (Foo::*fun)()，調用是傳遞的實參: &Foo::f；
• fun爲類成員函數指針，因此調用是要經過解引用的方式獲取成員函數*fun,即(foo1->*fun)();

 

2. std::function

function是一個擁有任何能夠以」(…)」符號進行調用的值的類型。特別地，bind的返回結果能夠賦值給function類型。function十分易於使用。（譯註：更直觀地，能夠把function當作是一種表示函數的數據類型，就像函數對象同樣。只不過普通的數據類型表示的是數據，function表示的是函數這個抽象概念。）例如：

 1         // 構造一個函數對象，
 2 
 3         // 它能表示的是一個返回值爲float，
 4 
 5         // 兩個參數爲int，int的函數
 6 
 7         function<float (int x, int y)> f;   
 8 
 9         // 構造一個可使用"()"進行調用的函數對象類型
10 
11         struct int_div {
12 
13                 float operator() (int x, int y) const
14 
15                      { return ((float)x)/y; };
16         };
17         f = int_div();                    // 賦值
18         cout<< f(5,3) <<endl;  // 經過函數對象進行調用
19         std::accumulate(b, e, 1, f);        // 完美傳遞

成員函數可被看作是帶有額外參數的自由函數：

 1         struct X {
 3                 int foo(int); 
 5         };
 9         // 所謂的額外參數，
11         // 就是成員函數默認的第一個參數，
13         // 也就是指向調用成員函數的對象的this指針 
15         function<int (X*, int)> f; 
17         f = &X::foo;            // 指向成員函數
21         X x;
23         int v = f(&x, 5);  // 在對象x上用參數5調用X::foo()
25         function<int (int)> ff = std::bind(f, &x, _1);    // f的第一個參數是&x
27         v = ff(5);                // 調用x.foo(5)

function對於回調函數、將操做做爲參數傳遞等十分有用。它能夠看作是C++98標準庫中函數對象mem_fun_t, pointer_to_unary_function等的替代品。一樣的，bind()也能夠被看作是bind1st()和bind2nd()的替代品，固然比他們更強大更靈活。

 

 

function是一組函數對象包裝類的模板，實現了一個泛型的回調機制。

引入頭文件

#include <functional>
using namespace std;
using namespace std::placeholders;  //bind的時候會用`

參考：http://www.cnblogs.com/hujian/archive/2012/12/07/2807605.html

fuction  bind:http://blog.csdn.net/fjb2080/article/details/7527715

咱們能夠調用的對象有不少，好比普通函數、函數指針、lambda表達式、函數對象和類的成員函數等。

無論採用哪一種方式，主要調用形式同樣（返回值類型、傳遞給調用的實參類型），咱們就可使用同一種形式來調用。

這個時候就能夠用到function模板，它給予咱們在調用的方式上更大的彈性。

請看一下三種不一樣的函數定義：

1 int add(int a, int b){//普通函數 2     return a+b;
3 }
4 auto mod=[](int a, int b){return a%b;}; //lambda 函數

5 struct divide{  //函數對象 6     int operator()(int m, int n){
7         return m/n;
8     }
9 };

這三種均可以使用同一種調用形式，int(int, int)，調用方式以下：

1  function<int(int,int)> func1= add;
2  function<int(int,int)> func2= divide();
3  function<int(int,int)> func3= mod;
4  cout<<func1(5, 6)<<endl;
5  cout<<func2(5, 6)<<endl;
6  cout<<func3(5, 6)<<endl;

學會了使用function，能夠繼續以下進行抽象定義，不一樣類型採用相同的調用方法：

1  map<string,function<int(int, int)>> funs =
2     {
3         {"+", add},
4         {"-", std::minus<int>()},//標準庫的函數，參數爲兩個整數，能夠參考前一篇博客
5         {"/", divide()},//類成員函數
6         {"*", [](int i,int j){return i*j;}},//lambda表達式
7         {"%", mod},
8     };
9     funs["+"](4,6);

以上就是function的簡單使用。下面是從另外一篇博客轉載的，使用function的引用來保存函數對象。考慮下面代碼：

 1 class CAdd
 2 
 3 {
 4 public:
 5     CAdd():m_nSum(0){NULL;}
 6     int operator()(int i)
 7     {
 8         m_nSum += i;
 9         return m_nSum;
10     }
11     int Sum() const
12     {
13         return m_nSum;
14     }
15 private:
16     int m_nSum;
17 };
18 int main(int argc, const char * argv[])
19 {
20     CAdd cAdd;
21     function<int(int)> funcAdd1 = cAdd;
22     function<int(int)> funcAdd2 = cAdd;
23     cout<<funcAdd1(10)<<endl;
24     cout<<funcAdd2(10)<<endl;
25     cout<<cAdd.Sum()<<endl;
26      return 0;
27 }

上面的輸出結果是 10 10 0。咱們將同一個函數對象賦值給了兩個function，而後分別調用這兩個function，但函數中的成員變量的值沒有保存，問題在哪裏？由於function的缺省行爲是拷貝一份傳遞給它的函數對象，因而f1,f2中保存的都是cAdd對象的拷貝。
C++11提供了ref和cref函數來提供對象的引用和常引用的包裝。要是function可以正確保存函數對象的狀態，能夠以下修改代碼：

1     function<int(int)> funcAdd3 = ref(cAdd);
2     function<int(int)> funcAdd4 = ref(cAdd);
3     cout<<funcAdd3(10)<<endl;
4     cout<<funcAdd4(10)<<endl;
5     cout<<cAdd.Sum()<<endl;

另外，兩個function之間賦值時，若是源function保存的是函數對象的拷貝，則目標function保存的也是函數對象的拷貝。若是源function保存的是對函數對象的引用，則目標function保存的也是函數對象的引用。