函数指针

 函数指针是指向函数的指针 变量。 因而“函数指针”本身首先应是 指针变量，只不过该指针变量指向函数。这正如用指针变量可指向 整型变量、字符型、 数组一样，这里是指向函数。如前所述，C在编译时，每一个函数都有一个入口地址，该入口地址就是函数指针所指向的地址。有了指向函数的指针变量后，可用该指针变量调用函数，就如同用指针变量可引用其他类型变量一样，在这些概念上是一致的。函数指针有两个用途：调用函数和做函数的 参数。

    函数指针的声明方法为：

    数据类型标志符 (指针变量名) (形参列表);

    注1：“函数类型”说明函数的返回类型，由于“()”的优先级高于“*”,所以指针变量名外的括号必不可少，后面的“形参列表”表示指针变量指向的函数所带的参数列表。例如：

　int func(int x);   /* 声明一个函数 */　　

    int (*f) (int x);    /* 声明一个函数指针 */　　

    f=func;   /* 将func函数的首地址赋给指针f */　　

    赋值时函数func不带括号，也不带参数，由于func代表函数的首地址，因此经过赋值以后，指针f就指向函数func(x)的代码的首地址。　　

    注2：函数括号中的形参可有可无，视情况而定。 　　

    下面的程序说明了函数指针调用函数的方法： 　　

#include<stdio.h>
int max(int x,int y){ return(x>y?x:y); }
void main()
{
   int (*ptr)(int, int);
　 int a,b,c;
　 ptr=max;
　 scanf("%d,%d",&a,&b);
　 c=(*ptr)(a,b);
　 printf("a=%d,b=%d,max=%d",a,b,c);
} 

     ptr是指向函数的指针变量，所以可把函数max()赋给ptr作为ptr的值，即把max()的入口地址赋给ptr,以后就可以用ptr来调用该函数，实际上ptr和max都指向同一个入口地址，不同就是ptr是一个指针变量，不像函数名称那样是死的，它可以指向任何函数，就看你想怎么做了。在程序中把哪个函数的地址赋给它，它就指向哪个函数。而后用指针变量调用它，因此可以先后指向不同的函数。不过注意，指向函数的指针变量没有++和--运算，用时要小心。 　　

     不过，在某些编译器中这是不能通过的。这个例子的补充如下。应该是这样的： 　　

     1.定义函数指针类型：　typedef int (*fun_ptr)(int,int); 　　

     2.申明变量，赋值：　　fun_ptr max_func=max; 也就是说，赋给函数指针的函数应该和函数指针所指的函数原型是一致的。　　

#include<stdio.h>
void FileFunc()
{
   printf("FileFunc\n");
}
void EditFunc()
{
　 printf("EditFunc\n");
}
void main()
{
　 typedef void (*funcp)();
　 funcp pfun= FileFunc;
　 pfun();
　 pfun = EditFunc;
　 pfun();　
}

1. 首先,在C语言中函数是一种function-to-pointer的方式,即对于一个函数,会将其自动转换成指针的类型.如:

#include<stdio.h>
void fun()
{
}
int main()
{
   printf("%p      %p      %p\n", &fun, fun, *fun);
   return 0;
}

这三个值的结果是一样的. 其实对于最后的那个*fun, 即使前面加上很多个*号, 其结果也不变, 即**fun, ***fun的结果都是一样的. 对于这个问题, 因为之前讲过函数是一种
function-to-pointer方式, 其会自动转换成指针的类型, &fun是该函数的地址, 为指针类型, fun是一个函数, 会转换成其指针类型, 而对于*fun, 由于fun已经变成了指针类型, 指向这个函数, 所以*fun就是取这个地址的函数, 而又根据function-to-pointer, 该函数也转变成了一个指针, 所以以此类推, 这三个值的结果是相同的.

2. 如何调用一个地址上的函数
    如果知道了一个函数所在的地址, 可以将其强制转化成某一种类型的函数指针, 然后再根据这个指针去调用这个地址的函数. 如:

#include<stdio.h>
typedef void (*pfun)(int);
void f(int i)
{
   printf("i = %d\n", i);
}
int main()
{
   unsigned long add;
   add = (unsigned long)f;
   ((pfun)add)(10);
   (*(pfun)add)(20);
   return 0;
}

    使用(void (*)(int))的方式可以将一个地址转换成一个带int参数且没有返回值的函数的指针类型, 然后再去调用, 由于第1点中讲的function-to-pointer, 所以最后两条语句中加与不加那个*号效果都是一样的. 在 嵌入式方面经常用到这种方式.

3. 函数指针数组的用法.

   有时候需要定义一个数组, 其内容为一系列的函数指针, 然后对其进行调用, 如:

#include<stdio.h>
typedef int (*pfun)(int, int);
int max(int v1, int v2)
{
   return (v1 > v2 ? v1 : v2);
}
int min(int v1, int v2)
{
   return (v1 < v2 ? v1 : v2);
}
int sum(int v1, int v2)
{
   return (v1 + v2);
}
int main()
{
   pfun p[3];
   p[0] = max;
   p[1] = min;
   p[2] = sum;
   printf("p[0] = %d\n", (p[0])(3, 5));
   printf("p[1] = %d\n", (p[1])(4, 6));
   printf("p[2] = %d\n", (p[2])(1, 2));
   return 0;
}

   虽然感觉这种方法有点累赘, 但是也算是一种使用的方式, 所以介绍一下.

4.返回一个指向数组的指针的方式

   可以让函数返回一个指向数组的一个指针, 如:

#include<stdio.h>
#include<stdlib.h>

typedef int (*pfun)[10];
pfun p()
{
   pfun m;
   int i;
   m = (pfun)malloc(10 * sizeof(int));
   if (m == NULL)
   {
      printf("malloc error\n");
      exit(1);
   }
   for (i = 0; i < 10; i++)
      *(*m+i) = i+1;
   return m;
}

int main()
{
   pfun a;
   int i;
   a = p();
   for (i = 0; i < 10; i++)
      printf("%d ", *(*a+i));
   printf("\ndone\n");
   return 0;
}

   这种方式中,int (*a)[10]是一个指向一维数组的一个指针, 而p()也是返回一个指向一维数组的一个指针.

5.返回一个函数指针的指针
   对这个问题, signal()函数是最好的例子

void (*signal (int signo, void (*func)(int)))(int);

   很多朋友刚开始看这个函数定义的时候是不太懂, 其实可以一步一步地慢慢看, 我以前是这样分析的, 希望能对大家有用.
   int (*p)(); 这是一个函数指针, p所指向的函数是一个不带任何参数, 并且返回值为int的一个函数.

   int (*fun())(); 这个式子与上面式子的区别在于用fun()代替了p,而fun()是一个函数,所以说就可以看成是fun()这个函数执行之后,它的返回值是一个函数指针,这个函数指针(其实就是上面的p)所指向的函数是一个不带任何参数,并且返回值为int的一个函数.所以说对于

void (*signal(int signo, void (*fun)(int)))(int);

   就可以看成是signal()函数(它自己是带两个参数,一个为整型,一个为函数指针的函数), 而这个signal()函数的返回值也为一个函数指针,这个函数指针指向一个带一个整型参数,并且返回值为void的一个函数.signal函数返回的其实是指向以前的信号处理程序的指针, 所以举一个例子来说明返回指向函数的指针的用法,如:

#include<signal.h>
#include<stdlib.h>
#include<stdio.h>

void sig_fun2(int signo)
{
   printf("in sig_fun2:%d\n", signo);
}
void sig_fun1(int signo)
{
   printf("in sig_fun1:%d\n", signo);
}
int main()
{
   unsigned long i;
   if (signal(SIGUSR1, sig_fun1) == SIG_ERR)
   {
      printf("signal fun1 error\n");
      exit(1);
   }

   (signal(SIGUSR1, sig_fun2))(30);
   printf("done\n");
   return 0;
}

6. 使用函数指针作为参数的情况

    在函数的参数中, 可能会带有一个函数指针, 这在signal()函数中是出现了的, 另外再写个例子如:

#include<stdio.h>

typedef int (*pfun)(int, int);
int max(int v1, int v2)
{
   return (v1 > v2 ? v1 : v2);
}
int min(int v1, int v2)
{
   return (v1 < v2 ? v1 : v2);
}
int sum(int v1, int v2)
{
   return (v1 + v2);
}
int fun(int a, int b, pfun call)
{
   return (call(a, b));
}
int main()
{
   printf("max=%d\n", fun(1, 2, max));
   printf("min=%d\n", fun(3, 4, min));
   printf("sum=%d\n", fun(5, 6, sum));
   return 0;
}

   其实在很多排序函数中就是使用的这个参数为函数指针的方式来进行调用的.