boost::bind

1.Boost::bind

　　在STL中，咱們常常須要使用bind1st，bind2st函數綁定器和fun_ptr,mem_fun等函數適配器，這些函數綁定器和函數適配器使用起來比較麻煩，須要根據是全局函數仍是類的成員函數，是一個參數仍是多個參數等作出不一樣的選擇，並且有些狀況使用STL提供的不能知足要求，因此若是能夠咱們最好使用boost提供的bind，它提供了統一的接口，提供了更多的支持，好比說它增長了shared_ptr，虛函數，類成員的綁定。

2.bind的工做原理

　　bind並非一個單獨的類或函數，而是很是龐大的家族，依據綁定的參數的個數和要綁定的調用對象的類型，總共有數十種不一樣的形式，編譯器會根據具體的綁定代碼制動肯定要使用的正確的形式，bind的基本形式以下：

template<class R,class F> bind(F f);
template<class R,class F,class A1> bind(F f,A1 a1);
namespace
{
boost::arg<1> _1;
boost::arg<2> _2;
boost::arg<3> _3;
….. //其餘6個佔位符
};

1 template<class R,class F> bind(F f);
2 template<class R,class F,class A1> bind(F f,A1 a1);
3 namespace
4 {
5 boost::arg<1> _1;
6 boost::arg<2> _2;
7 boost::arg<3> _3;
8 …..                                     //其餘6個佔位符
9 };

　　bind接收的第一個參數必須是一個可調用的對象f，包括函數、函數指針、函數對象、和成員函數指針，以後bind最多接受9個參數，參數數量必須與f的參數數量相等，這些參數被傳遞給f做爲入參。 綁定完成後，bind會返回一個函數對象，它內部保存了f的拷貝，具備operator()，返回值類型被自動推導爲f的返回類型。在發生調用時這個函數對象將把以前存儲的參數轉發給f完成調用。例如，有一個函數func，它的形式是：

func(a1,a2);

那麼，他將等價於一個具備無參operator()的bind函數對象調用：

bind(func,a1,a2)();

　　這是bind最簡單的形式，bind表達式存儲了func和a一、a2的拷貝，產生了一個臨時函數對象。由於func接收兩個參數，而a1和a2的拷貝傳遞給func完成真正的函數調用。

　　bind的真正威力在於它的佔位符，它們分別定義爲_1,_2,_3,一直到 _9,位於一個匿名的名字空間。佔位符能夠取代bind參數的位置，在發生調用時才接受真正的參數。佔位符的名字表示它在調用式中的順序，而在綁定的表達式中沒有沒有順序的要求，_1不必定必須第一個出現，也不必定只出現一次，例如：

bind(func,_2,_1)(a1,a2);

　　返回一個具備兩個參數的函數對象，第一個參數將放在func的第二個位置，而第二個參數則放在第一個位置，調用時等價於：

func(a2,a1);

 

3.bind的應用場景

3.1 綁定普通函數

　　bind能夠綁定普通函數，包括函數、函數指針，假設我麼有以下的函數定義：

int f(int a,int b){return a+b;}   //二元函數
int g(int a,int b,int c) {return a+b+c;} //三元函數
typedef int (*f_type)(int,int);      //函數指針定義
typedef int (*g_type)(int,int,int); //函數指針定義

 

　　那麼，bind(f,1,2) 將返回一個無參調用函數對象，等價於f(1,2),bind(q,1,2,3)一樣返回一個無參調用的函數對象，等價於 g(1,2,3)。這兩個綁定表達式沒有使用佔位符，而是給出了所有的具體參數，代碼：

cout<<bind(f,1,2)()<<endl;
cout<<bind(g,1,2,3)()<<endl;

　　至關於：

cout<<f(1,2)<<endl;
cout<<g(1,2,3)<<endl; 

　　使用佔位符bind能夠有更多的變化，這纔是它真正應該作的工做，下面列出了一些佔位符的用法：

bind(f,_1,9)(x);  //f(x,9),至關於bind2nd(f,9)
bind(f,_1,_2)(x,y); //f(x,y)
bind(f,_2,_1)(x,y); //f(y,x)
bind(f,_1,_1)(x,y); //f(x,x),y參數被忽略
bind(g,_1,8,_2)(x,y) //g(x,8,y)
bind(g,_3,_2_2)(x,y,z) //g(z,y,y),x參數被忽略

 

　　注意：必須在綁定表達式中提供函數要求的全部參數，不管是真實參數仍是佔位符都可以。佔位符能夠出現也能夠不出現，出現的順序和數量沒有限定，但不能使用超過函數參數數量的佔位符，好比在綁定f是不能用_3,在綁定g時不能使用_4，也不能寫bind(f,_1,_2,_2)，這樣的形式會致使編譯錯誤。bind徹底能夠代替標準庫中的bind1st和bind2nd，使用bind(f,N,_1)和bind(f,_1,N)。要注意的是它們均使用了一個佔位符，bind1st把第一個參數用固定值代替，bind2nd把第二個參數用固定值代替。bind也能夠綁定函數指針，用法相同，例如：

f_type pf = f;
g_type pg = g;
int x =1,y=2,z=3;
cout<<bind(pf,_1,9)(x)<<endl; //(*pf(x,9))
cout<<bind(pg,_3,_2,_2)(x,y,z)<<endl; //(*pg)(z,y,y)

 

3.2 bind綁定成員函數

　　類的成員函數不一樣於普通的函數，由於成員函數指針不能直接調用operator(),它必須被綁定到一個對象或指針，而後才能獲得this指針進而調用成員函數。所以bind須要 「犧牲」一個佔位符，要求提供一個類的實例、引用或者指針，經過對象做爲第一個參數來調用成員函數，即：

bind(&X::func,x,_1,_2,…)

　　這意味着使用成員函數時只能最多綁定8個參數。例如，有一個類demo

struct demo
{
    int f(int a,int b){return a+b;}
};

　　那麼，下面的bind表達式都是成立的：

demo a,&ra = a;    //類的實例對象和引用
demo * p = & a;     //指針
cout<<bind(&demo::f,a,_1,20)(10)<<endl;
cout<<bind(&demo::f,ra,_2,_1)(10,20)<<endl;
cout<<bind(&demo::f,p,_1,_2)(10,20)<<endl;

 

　　注意：咱們必須在成員函數前面加上取地址的操做符&，代表這是一個成員函數指針，不然會沒法編譯經過，這是與綁定函數的一個小小的不一樣。bind一樣支持綁定虛擬成員函數，用法與非虛函數相同，虛函數的行爲將由實際調用發生時的實例來決定。

3.3 bind綁定成員變量

　　bind的另外一個對類的操做是它能夠綁定public成員變量，用法與綁定成員函數相似，只須要把成員變量名像一個成員函數同樣去使用。例如：

vector<point> v(10);
vector<int> v2(10);
transform(v.begin(),v.end(),v2.begin(),bind(&point::x,_1));
BOOST_FOREACH(int x,v2) cout<<x<<「,」;

　　代碼中的bind(&point::x,_1)取出point對象的成員變量x，transform算法調用bind表達式操做容器v,逐個把成員變量填入到v2中。看到這裏感到有點困惑，有點難以理解：bind返回的是一個函數對象，該對象對「（）」進行了重載，在transform調用該重載函數應該是將v中的每個成員變量做爲參數傳進去，從而取出每個元素的x變量。

　　使用bind能夠實現SGISTL/STLport中的非標準函數適配器select1st和select2nd的功能，直接選擇出pair對象first和second成員，例如：

typedef pair<int,string> pair_t;
pair_t p(123,」string」);
cout<<bind(&pair_t::first,p)()<<endl;
cout<<bind(&pair_t::second,p)()<<endl;

3.4 綁定函數對象

　　bind不只可以綁定函數和函數指針，也可以綁定任意的函數對象，包括標準庫中預約義的函數對象。若是函數對象有內部類型定義result_type，那麼bind能夠自動推導出返回值類型，用法與普通函數同樣。但若是函數對象沒有定義result_type，則須要在綁定形式上作一點改動，用模板參數指明返回類型，像這樣：

bind<result_type>(Functor,…);

　　標準庫和Boost庫中的大部分函數都具備result_type定義，所以不須要特別的形式就能夠直接使用bind,例如：

bind(std::greater<int>(),_1,10);  //檢查 x>10
bind(plus<int>(),_1,_2); //執行 x+y
bind(modulus<int>(),_1,3), //執行 x%3

　　對於自定義的函數對象，若是沒有result_type類型定義，例如：

struct f
{
    int operator() (int a,int b) {return a +b;}
};

　　那麼咱們必須指明

bind<int> (f(),_1,_2)(10,20)<<endl;

　　這種寫法所燒會有些不方便，所以，在編寫本身的函數對象時，最好遵循規範爲它們增長內部typedef result_type,這將使函數對象與其餘的標準庫和Boost庫組件配合工做。

3.5 使用ref庫

　　bind採用拷貝的方式保存綁定對象和參數，這意味着綁定表達式中的每個變量都會有一份拷貝，若是函數對象或值參數很大、拷貝代價很高，或者沒法拷貝，那麼bind的使用就會受到限制。所以bind庫能夠搭配ref庫使用，ref庫包裝了對象的引用，可讓bind存儲對象引用的拷貝，從而下降了拷貝的代價。但這也帶來了一個隱患，由於有時候bind的調用可能會延後好久，程序員必須保證bind被調用時引用是有效的。若是調用是引用的變量或者函數對象你被銷燬了，那麼將會發生未定義行爲。ref配合bind用法的代碼以下：

int x = 10;
cout<<bind(g,_1,cref(x),ref(x))(10)<<endl;
f af;
cout<<bind<int>(ref(af),_1,_2)(10,20)<<endl;

　　下面的代碼則由於引用失效，引起未定義行爲：

int x = 10;
BOOST_AUTO(r,ref(x));
{
    int * y = new int(20);
    r = ref(*y);
    cout<<r<<endl;
    cout<<bind(g,r,1,1)()<<endl;
    delete y;
}
cout<<bind(g,r,1,1)()<<endl;

 

3.6 存儲bind表達式

　　不少時候咱們須要把寫好的bind表達式存儲起來，以便稍後再度使用，但bind表達式生成的對象類型聲明很是複雜，一般沒法寫出正確的類型，所以可使用typeof庫的BOOST_AUTO宏來輔助咱們，例如：

BOOST_AUTO(x,bind(greater<int>(),_1,_2));
cout<<x(10,20)<<endl;

　　bind能夠嵌套，一個bind表達式生成的函數對象能夠被另外一個bind再綁定，從而實現相似f(g(x))的形式，若是咱們有f(x)和g(x)兩個函數，那麼f(g(x))的bind表達式就是：

bind(f,bind(g,_1))(x)

　　使用bind的嵌套用法必須當心，它不太容易一次寫對，也不太容易理解，超過兩個以上的bind表達式一般只能被編譯器讀懂，必須配合良好的註釋纔可以使用bind嵌套用法。

3.7 綁定非標準函數

　　bind能夠適配任何一種C++中的函數，但標準形式bind(f,…)不是適用所用的狀況，有些非標準函數沒法制動推導出返回值類型，典型的就是C中的可變參數函數printf()。必須用bind<int>(printf,…)(…)，例如：

bind<int>(printf,」%d+%d=%d\n」,_1,_1,_2)(6,7);

　　bind的標準形式也不能支持使用了不一樣的調用方式，如：__stdcall、__fastcall、extern」C」的函數，一般bind把他們看作函數對象，須要顯示的指定bind的返回值類型才能綁定。