函数指针实例

1.      定义

每一个函数都占用一段内存单元，它们有一个起始地址，指向函数入口地址的指针称为函数指针。
2.     语法
指向函数的指针变量的一般定义形式为：
数据类型 (*指针变量名)(参数表);
3.     说明
1） 函数指针的定义形式中的数据类型是指函数的返回值的类型。
2） 区分下面两个语句：
int (*p)(int a, int b); //p是一个指向函数的指针变量，所指函数的返回值类型为整型
int *p(int a, int b); //p是函数名，此函数的返回值类型为整型指针
3） 指向函数的指针变量不是固定指向哪一个函数的，而只是表示定义了一个这样类型的变量，它是专门用来存放函数的入口地址的；在程序中把哪一个函数的地址赋给它，它就指向哪一个函数。
4） 在给函数指针变量赋值时，只需给出函数名，而不必给出参数。
如函数max的原型为：int max(int x, int y); 指针p的定义为：int (*p)(int a, int b); 则p = max;的作用是将函数max的入口地址赋给指针变量p。这时，p就是指向函数max的指针变量，也就是p和max都指向函数的开头。
5） 在一个程序中，指针变量p可以先后指向不同的函数，但一个函数不能赋给一个不一致的函数指针（即不能让一个函数指针指向与其类型不一致的函数）。
如有如下的函数：int fn1(int x, int y); int fn2(int x);
定义如下的函数指针：int (*p1)(int a, int b); int (*p2)(int a);
则
p1 = fn1; //正确
p2 = fn2; //正确
p1 = fn2; //产生编译错误
6） 定义了一个函数指针并让它指向了一个函数后，对函数的调用可以通过函数名调用，也可以通过函数指针调用（即用指向函数的指针变量调用）。
如语句：c = (*p)(a, b); //表示调用由p指向的函数(max)，实参为a,b，函数调用结束后得到的函数值赋给c。
7） 函数指针只能指向函数的入口处，而不可能指向函数中间的某一条指令。不能用*(p+1)来表示函数的下一条指令。
8） 函数指针变量常用的用途之一是把指针作为参数传递到其他函数。

#include <iostream>  
using namespace std;  
#include <conio.h>  
  
int max(int x, int y); //求最大数  
int min(int x, int y); //求最小数  
int add(int x, int y); //求和  
void process(int i, int j, int (*p)(int a, int b)); //应用函数指针  
  
int main()  
{  
    int x, y;  
    cin>>x>>y;  
  
    cout<<"Max is: ";  
    process(x, y, max);  
  
    cout<<"Min is: ";  
    process(x, y, min);  
  
    cout<<"Add is: ";  
    process(x, y, add);  
  
    getch();  
    return 0;  
}  
  
int max(int x, int y)  
{  
    return x > y ? x : y;  
}  
  
int min(int x, int y)  
{  
    return x > y ? y : x;  
}  
  
int add(int x, int y)  
{  
    return x + y;  
}  
  
void process(int i, int j, int (*p)(int a, int b))  
{  
    cout<<p(i, j)<<endl;  
}  

在C/C++中存在着函数指针，即指向函数的指针。我目前已知的两种使用方法是：

#include <string.h>
#include <stdio.h>
typedef int* PINNT;
#define PP int*

int funcA(int a,int b);
int funcB(int* a,int *b);
int main(int argc, char *argv[])
{
int (*func)(int,int);
//func = &funcA;
func = funcA;
//两种赋值给函数指针的方法都可以
printf("%d",func(1,10));
//printf("%d",(*func)(1,10));
//两种调用函数指针的方法都可以
//两种赋值方法和两种调用方法可以任选一种组合

}

int funcA(int a,int b)
{
return a + b;
}

int funcB(int* a,int *b)
{
(*a) = (*a) + (*b);
return 1;
}



这里int (*func)(int,int)定义了一个函数指针变量，可以接受函数名或者函数名的指针(这里我还没有很清楚)。



然后我在CSDN上面找到了一个例子，据说是华为的面试题目，代码如下，这时程序正常输出值为110。

[cpp] view plain copy
#include <stdio.h>
int inc(int a)
{
return(++a);
}

int multi(int*a,int*b,int*c)
{
return(*c=*a**b);
}

typedef int(FUNC1)(int);
typedef int(FUNC2)(int*,int*,int*);

void show(FUNC2 fun,int arg1, int*arg2)
{
FUNC1 *p = &inc;
int temp =p(arg1);
fun(&temp,&arg1, arg2);
printf( "%d\n ",*arg2);
}

main()
{
int a;
show(multi,10,&a);
getchar();
return 0;
}
一开始我没有理解这个用法的时候，以为这里使用的方法与方法一相同，故直接写成


typedef int(FUNC1)(int);
typedef int(FUNC2)(int*,int*,int*);

void show(FUNC2 fun,int arg1, int*arg2)
{
FUNC1 = inc;
int temp =p(arg1);
fun(&temp,&arg1, arg2);
printf( "%d\n ",*arg2);
}

这时候，编译器给出的提示是：

1>d:\vctest\test4\test4\test4.c(17) : error C2513: 'int (int)' : no variable declared before '='

FUNC1 = inc这个语句的左边没有变量被申明，这个错误提示说明利一点：FUNC是一种类型而不是一个变量。做出如下更正：


FUNC1 *p = inc;

程序正确，更加证明了

[cpp] view plain copy
typedef int(FUNC1)(int);
typedef int(FUNC2)(int*,int*,int*);
语句定义了两个自己的数据类型FUNC1和FUNC2，这两个类型申明的变量用保存函数指针



也可以采用下面的方式进行定义:

[cpp] view plain copy
typedef int (*FUNC1)(int);
typedef int (FUNC2)(int*,int*,int*);

void show(FUNC2 fun,int arg1, int*arg2)
{
FUNC1 p = inc;
int temp = p(arg1);
fun(&temp,&arg1, arg2);
printf( "%d\n ",*arg2);
}



以上例子,涉及到的概念有函数指针,函数类型和函数指针变量

函数指针变量有两种实现方法:

1. 先申明函数指针类型,在用函数指针类型申明函数指针变量

//typedef void FunType(int); -- FunType：同样是一个函数指针类型。

[cpp] view plain copy
typedef void (*PF)(int,int);
//使用函数指针类型申明的变量就是函数指针变量
//PF a = &inc//PF a = inc
2. 直接定义一个函数指针变量



[cpp] view plain copy
void (*fPV)(int,int);
fvp = inc // fvp = &inc

函数类型与函数指针变量

如何定义函数类型呢



[cpp] view plain copy
typedef void (FT)(int,int);
申明的函数类型如何使用呢？



首先可以用来申明函数：

FT x，y等价于：

void x(int,int);

void y(int,int);

请看如下的示例：

[cpp] view plain copy
#include <stdio.h>

typedef int (FT)(int*,int*);
FT x,y;


main()
{
int a = 1,b=2;
x(&a,&b);
(*y)(&a,&b);
}

int x(int* a,int*b){
*a = *a + *b;
printf("%d\n",*a);
}

int y(int*a,int* b){
*a = *a * (*b);
printf("%d\n",*a);
}



上面的程序输出3和6



[cpp] view plain copy
#include <stdio.h>

typedef int (FT)(int*,int*);
FT x,y,*z,u;


main()
{
int a = 1,b=2;
x(&a,&b);
(*y)(&a,&b);
z = x;//这里x是一个函数名,但是编译器会把函数名转换为函数指针变量,所以也可以显式写成z = &x;
x(&a,&b);
//u = x;//这里出错了这里u是一个函数名称,是一个指针常量,类似于数组名称,是不能够被赋值的
}

int x(int* a,int*b){
*a = *a + *b;
printf("%d\n",*a);
}

int y(int*a,int* b){
*a = *a * (*b);
printf("%d\n",*a);
}

上面的例子中FT *Z其实是申明了一个指向函数的函数指针变量，类似于int（*z）(int*,int*)。



最后再来看下那个困扰了我很久的例子吧：

[cpp] view plain copy
#include <stdio.h>
int inc(int a)
{
return(++a);
}

int multi(int*a,int*b,int*c)
{
return(*c=*a**b);
}

typedef int (*FUNC1)(int);
typedef int (FUNC2)(int*,int*,int*);
typedef int (FUNC3)(int*,int*,int*);

void show(FUNC2 *fun,int arg1, int*arg2)
//void show(FUNC2 fun,int arg1, int*arg2)//这里做这样的声明也一样是对的
{
FUNC1 p = &inc;
FUNC2 *q = multi;
int temp = (*p)(arg1);
(*fun)(&temp,&arg1, arg2);
//fun(&temp,&arg1, arg2); //这里的两种调用方法和上面的恶两种声明方法可以任意组合，,原因是函数名和函数指针常量的隐式转换
printf( "%d\n ",*arg2);
}

main()
{
int a;
show(multi,1,&a);
getchar();
return 0;
}
最让我疑惑的是

void show(FUNC2 *fun,int arg1, int*arg2)
//void show(FUNC2 fun,int arg1, int*arg2)//这里做这样的声明也一样是对的

这两种声明方式都是对的，采用void show(FUNC2 fun,int arg1, int*arg2)//这里做这样的声明也一样是对的这种方式声明， show(multi,1,&a);调用时正确的，

而前面的代码中，我也说过//u = x;//这里出错了这里u是一个函数名称,是一个指针常量,类似于数组名称,是不能够被赋值的， 这个问题困扰我很久啊，仔细考虑之后，我个人的观点是：void show(FUNC2 fun,int arg1, int*arg2)使用一个函数做为形式参数，调用时传递一个函数名字给他就可以，也可以传递一个函数常量指针。类比于使用指针常量或者数组作函数书参数的时候

[cpp] view plain copy
#include <stdio.h>

typedef void (FT)(int* const a);
FT z;
void main()
{
int a[]={1,2,3,4,5};
int b = 5;
int *c = &b;
z(a);
//但是如果在这里给a = c是不对的
}

void z(int* const a)
{
printf("%d",*a);
}