以下内容转自【 http://mingxinglai.com/cn/2012/09/function-object/ 】，有删改。
《C++标准程序库》里对仿函数的解释是：仿函数是泛型编程强大威力和纯粹抽象概念的又一例证。你可以说，任何东西，只要其行为像函数，它就是一个函数。因此如果你定义了一个对象，行为像函数，它就可以被当做函数来用。
那么，什么才算具备函数行为呢？所谓函数行为，是指可以”使用小括号传递参数，籍以调用某个东西”。例如：
function(argc1, argc2);
如果你指望对象也可以如此这般，就必须让它们也可以被”调用”——通过小括号的运用和参数的传递。你只需要定义operator()，并给予合适的参数型别：
class X
{
public:
// define 'function call' operator
return-value operator()(arguments) const;
......
};
现在，你可以把这个类别的对象当做函数来调用了：
X fo; ...... // call operator () for function object to fo(argc1, argc2);
上述调用等价于：
fo.operator() (argc1, argc2);
总结如下:
函数对象是一个普通对象
重载了operator ()操作符
函数对象一般都比较简单，主要用到operator()操作，其他成员函数和成员变量都是为operator()服务。
以下内容转自【 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);
既然函数对象与函数指针在使用方式上没什么区别，那为什么要用函数对象呢？很简单，函数对象可以携带附加数据，而指针就不行了。
下面就举个使用附加数据的例子：
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!
大功告成了，终于可以方便保存成员函数指针，以备调用了。
发表评论