好文轉載：函數對象

原文地址：http://www.cnblogs.com/ly4cn/archive/2007/07/21/826885.html

 

函數對象不是函數指針。但是，在程序代碼中，它的調用方式與函數指針一樣，後面加個括號就可以了。
　　這是入門級的隨筆，說的是函數對象的定義，使用，以及與函數指針，成員函數指針的關係。 
沐楓小築
函數對象實質上是一個實現了operator()--括號操作符--的類。
例如：

class Add
{
public:
  int operator()(int a, int b)
  {
    return a + b;
  }
};

 

Add add; // 定義函數對象
cout << add(3,2); // 5

函數指針版本就是：

int AddFunc(int a, int b)
{
  return a + b;
}
typedef int (*Add) (int a, int b);

 

Add add = &AddFunc;
cout << add(3,2); // 5

呵呵，除了定義方式不一樣，使用方式可是一樣的。都是：

cout << add(3,2);

既然函數對象與函數指針在使用方式上沒什麼區別，那爲什麼要用函數對象呢？很簡單，函數對象可以攜帶附加數據，而指針就不行了。
下面就舉個使用附加數據的例子：

class less
{
public:
    less(int num):n(num){}
    bool operator()(int value)
    {
        return value < n;
    }
private:
    int n;
};

使用的時候：

    less isLess(10);
    cout << isLess(9) << " " << isLess(12); // 輸出 1 0

這個例子好象太兒戲了，換一個：

const int SIZE = 5;
int array[SIZE] = { 50, 30, 9, 7, 20};
// 找到小於數組array中小於10的第一個數的位置
int * pa = std::find_if(array, array + SIZE, less(10)); // pa 指向 9 的位置
// 找到小於數組array中小於40的第一個數的位置
int * pb = std::find_if(array, array + SIZE, less(40));　// pb 指向 30 的位置

這裏可以看出函數對象的方便了吧？可以把附加數據保存在函數對象中，是函數對象的優勢所在。
它的弱勢也很明顯，它雖然用起來象函數指針，但畢竟不是真正的函數指針。在使用函數指針的場合中，它就無能爲力了。例如，你不能將函數對象傳給qsort函數！因爲它只接受函數指針。

要想讓一個函數既能接受函數指針，也能接受函數對象，最方便的方法就是用模板。如：

template<typename FUNC>
int count_n(int* array, int size, FUNC func)
{
    int count = 0;
    for(int i = 0; i < size; ++i)
        if(func(array[i]))
            count ++;
    return count;
}

這個函數可以統計數組中符合條件的數據個數，如：

const int SIZE = 5;
int array[SIZE] = { 50, 30, 9, 7, 20};
cout << count_n(array, SIZE, less(10)); // 2

用函數指針也沒有問題：

bool less10(int v)
{
    return v < 10;
}
cout << count_n(array, SIZE, less10); // 2

另外，函數對象還有一個函數指針無法匹敵的用法：可以用來封裝類成員函數指針！
因爲函數對象可以攜帶附加數據，而成員函數指針缺少一個類實體(類實例)指針來調用，因此，可以把類實體指針給函數對象保存起來，就可以用於調用對應類實體成員函數了。

template<typename O>
class memfun
{
public:
    memfun(void(O::*f)(const char*), O* o): pFunc(f), pObj(o){}
    void operator()(const char* name)
    {
        (pObj->*pFunc)(name);
    }
private:
    void(O::*pFunc)(const char*);
    O* pObj;
};

class A
{
public:
    void doIt(const char* name)
    { cout << "Hello " << name << "!";}
};

 

    A a;
    memfun<A> call(&A::doIt, &a); // 保存 a::doIt指針以便調用
    call("Kitty"); // 輸出 Hello Kitty!

大功告成了，終於可以方便保存成員函數指針，以備調用了。

不過，現實是殘酷的。函數對象雖然能夠保有存成員函數指針和調用信息，以備象函數指針一樣被調用，但是，它的能力有限，一個函數對象定義，最多隻能實現一個指定參數數目的成員函數指針。
標準庫的mem_fun就是這樣的一個函數對象，但是它只能支持0個和1個參數這兩種成員函數指針。如 int A::func()或void A::func(int)、int A::func(double)等等，要想再多一個參數如：int A::func(int, double)，不好意思，不支持。想要的話，只有我們自已寫了。
而且，就算是我們自已寫，能寫多少個？5個？10個？還是100個（這也太恐怖了）？
好在boost庫提供了boost::function類，它默認支持10個參數，最多能支持50個函數參數(多了，一般來說這夠用了。但它的實現就是很恐怖的：用模板部份特化及宏定義，弄了幾十個模板參數，偏特化(編譯期)了幾十個函數對象。

----
C++0x已經被接受的一個提案，就是可變模板參數列表。用了這個技術，就不需要偏特化無數個函數對象了，只要一個函數對象模板就可以解決問題了。期待吧。