函数对象

函数对象不是函数指针。但是,在程序代码中,它的调用方式与函数指针一样,后面加个括号就可以了。
这是入门级的随笔,说的是函数对象的定义,使用,以及与函数指针,成员函数指针的关系。 
沐枫小筑
函数对象实质上是一个实现了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!

大功告成了,终于可以方便保存成员函数指针,以备调用了。

本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/hxzhang1024/archive/2009/02/12/3882276.aspx

posted @ 2009-09-15 13:40  回忆1919  阅读(848)  评论(0编辑  收藏  举报