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