眾所周知，STL使用起來非常方便，其中仿函數(functor)扮演了一個非常重要的角色。靈活運用仿函數的使用對于發揮STL強大功能非常關鍵。本文詳細介紹了如何使用mem_fun和mem_fun1來綁定類成員函數，使之成為functor
什么是仿函數？就是一個重載了"()"運算符的struct，例如：
struct print_obj{
void
operator(int a)const{
cout<<a<<endl;
}
};
在STL的許多算法(algorithm)中都需要使用functor. 如:for_each.
同樣在關聯容器中也需要使用functor, 如map,
set等。經常在使用STL算法的時候，經常需要把仿函數和類聯系在一起，如果可以直接使用類的成員函數作為仿函數，那就方便多了。mem_fun的功能就是如此。
先看個簡單的例子：
struct D {
D(int
i=0){num=i;}
int
num;
};
struct print_D{
void operator()(const
D* d)const{
cout<<"I
am D. my num="<<d->num<<endl;
}
};
int main()
{
vector<D*> V;
V.push_back(new D(1));
V.push_back(new D(2));
V.push_back(new D);
V.push_back(new D(3));
for_each(V.begin(), V.end(),
print_D());
}
編譯輸出：
I am D. my num=1
I am D. my num=2
I am D. my num=0
I am D. my num=3
如果使用mem_fun，會方便很多：
struct D {
D(int
i=0){num=i;}
void print() { cout
<< "I'm a D. my num=" << num<<
endl; }
int
num;
};
int main()
{
vector<D*> V;
V.push_back(new D(1));
V.push_back(new D(2));
V.push_back(new D);
V.push_back(new D(3));
for_each(V.begin(), V.end(), mem_fun(&D::print));
}
是不是省了一個仿函數？方便多了，沒錯吧。這也更符合面向對象的規則。不過這樣好像讓人難以理解，這里告訴你一個理解STL的訣竅：
如果對STL的某個部分不了解，就去看源碼，源碼是最好的老師。
那看看源碼是怎么回事，在SGI STL的stl_function.h:
template <class
_Ret, class _Tp>
inline mem_fun_t<_Ret,_Tp> mem_fun(_Ret (_Tp::*__f)())
{ return mem_fun_t<_Ret,_Tp>(__f); }
原來mem_fun返回的是一個對象:mem_fun_t<_Ret,_Tp>.(不要嫌人家命名太怪異).那mem_fun_t<_Ret,_Tp>又是什么東東？還是看源碼：
template <class
_Ret, class _Tp>
class mem_fun_t :
public unary_function<_Tp*,_Ret>
{
public:
explicit
mem_fun_t(_Ret (_Tp::*__pf)()) : _M_f(__pf) {}
_Ret operator()(_Tp* __p) const
{ return (__p->*_M_f)();
}
private:
_Ret (_Tp::*_M_f)();
};
看明白了嗎？原來mem_fun_t就是一個functor，這下就滿足了for_each的要求了。其調
用流程是這樣的，for_each把vector中的元素傳送給mem_fun，mem_fun自己產生一個仿函數mem_fun_t，然后仿函數調用其
重載的()。過程就這么簡單。當然你不能對其他類的成員函數進行綁定，因為在for_each調用過程中，會傳遞其*iterator值，如果是其他類的
成員函數，那么這個類的對象無法傳入，當然就無法完成任務了。
這里使用的是vector<D*> V; 在mem_fun_t構造函數中，剛好需要指針，如果不是D*,
而是使用vector<D> V; 還能用嗎？
這是你需要使用的是mem_fun_ref。把程序改成：
struct D {
D(int
i=0){num=i;}
void print() { cout
<< "I'm a D. my num=" << num<<
endl; }
int
num;
};
int main()
{
vector<D> V;
V.push_back(D(1));
V.push_back( D(2));
V.push_back( D());
V.push_back( D(3));
for_each(V.begin(), V.end(), mem_fun_ref(&D::print));
}
一切都OK了。
mem_fun對于一些多態的虛函數也十分有用，注意看下面的例子：
struct B {
virtual void
print() = 0;
};
struct D1 : public B {
void print() { cout
<< "I'm a D1" << endl; }
};
struct D2 : public B {
void print() { cout
<< "I'm a D2" << endl; }
};
int main()
{
vector<B*> V;
V.push_back(new D1);
V.push_back(new D2);
V.push_back(new D2);
V.push_back(new D1);
for_each(V.begin(), V.end(), mem_fun(&B::print));
}