函数指针，函数名，函数对象

最新推荐文章于 2021-11-18 15:25:44 发布

wlgoc

最新推荐文章于 2021-11-18 15:25:44 发布

阅读量521

点赞数

本文链接：https://blog.csdn.net/me4weizhen/article/details/51571034

版权

函数名字是一个函数指针常量，不可以更改。函数指针是一个函数指针变量，可以更改。这二者相当于int const int的关系。也可以类似 int int*的关系。所以调用的时候赋值的时候可以用&*也可以不用。

函数对象是重载了（）的一个类

如

class Add{

public:

int operator（）(int a,int b){return a+b;}

};

Add add;

add(2.4)则为6.函数对象是函数指针的进一步拓展。

http://www.cnblogs.com/ly4cn/archive/2007/07/21/826885.html

函数对象，关键在于他是一个类的对象。起到了函数的作用。它重载了（），对象才可以用。类没法重载的对不。

函数对象可以携带附加数据，而指针就不行了。
下面就举个使用附加数据的例子：

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函数！因为它只接受函数指针。

类名直接带括号less(19)???什么意思？待补充。

http://www.cnblogs.com/lvpengms/archive/2011/02/21/1960078.html

从一般的函数回调意义上来说，函数对象和函数指针是相同的，但是函数对象却具有许多函数指针不具有的有点，函数对象使程序设计更加灵活，而且能够实现函数的内联（inline）调用，使整个程序实现性能加速。
函数对象：这里已经说明了这是一个对象，而且实际上只是这个对象具有的函数的某些功能，我们才称之为函数对象，意义很贴切，如果一个对象具有了某个函数的功能，我们变可以称之为函数对象。
如何使对象具有函数功能呢，很简单，只需要为这个对象的操作符()进行重载就可以了，如下：

  
  
   
   class
   
    A{

   
   public
   
   :

   
   int
   
    
   
   operator
   
   ()(
   
   int
   
    x){
   
   return
   
    x;}
};
A a;
a(
   
   5
   
   );

这样a就成为一个函数对象，当我们执行a(5)时，实际上就是利用了重载符号()。
函数对象既然是一个“类对象”，那么我们当然可以在函数形参列表中调用它，它完全可以取代函数指针！如果说指针是C的标志，类是C++特有的，那么我们也可以说指针函数和函数对象之间的关系也是同前者一样的！（虽然有些严密）。当我们想在形参列表中调用某个函数时，可以先声明一个具有这种函数功能的函数对象，然后在形参中使用这个对象，他所作的功能和函数指针所作的功能是相同的，而且更加安全。
下面是一个例子：

  
  
   
   class
   
    Func{

   
   public
   
   :
    
   
   int
   
    
   
   operator
   
   () (
   
   int
   
    a, 
   
   int
   
    b)
    {
        cout
   
   <<
   
   a
   
   <<
   
   '
   
   +
   
   '
   
   <<
   
   b
   
   <<
   
   '
   
   =
   
   '
   
   <<
   
   a
   
   +
   
   b
   
   <<
   
   endl;
        
   
   return
   
    a;
    }
};

   
   int
   
    addFunc(
   
   int
   
    a, 
   
   int
   
    b, Func
   
   &
   
    func)
{
    func(a,b);
    
   
   return
   
    a;
}
Func func;
addFunc(
   
   1
   
   ,
   
   3
   
   ,func);

上述例子中首先定义了一个函数对象类，并重载了()操作符，目的是使前两个参数相加并输出，然后在addFunc中的形参列表中使用这个类对象，从而实现两数相加的功能。
如果运用泛型思维来考虑，可以定一个函数模板类，来实现一般类型的数据的相加：

  
  
   
   class
   
    FuncT{

   
   public
   
   :
    template
   
   <
   
   typename T
   
   >
   
   
    T 
   
   operator
   
   () (T t1, T t2)
    {
        cout
   
   <<
   
   t1
   
   <<
   
   '
   
   +
   
   '
   
   <<
   
   t2
   
   <<
   
   '
   
   =
   
   '
   
   <<
   
   t1
   
   +
   
   t2
   
   <<
   
   endl;
        
   
   return
   
    t1;
    }
};
template 
   
   <
   
   typename T
   
   >
   
   
T addFuncT(T t1, T t2, FuncT
   
   &
   
    funct)
{
    funct(t1,t2);
    
   
   return
   
    t1;
}
FuncT funct;
addFuncT(
   
   2
   
   ,
   
   4
   
   ,funct);
addFuncT(
   
   1.4
   
   ,
   
   2.3
   
   ,funct);