函数指针的使用方法

‘壹’ c++的函数指针是怎么用的呀

函数指针，即指向函数的指针。

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>
usingnamespacestd;
#include<conio.h>

intmax(intx,inty);//求最大数
intmin(intx,inty);//求最小数
intadd(intx,inty);//求和
voidprocess(inti,intj,int(*p)(inta,intb));//应用函数指针

intmain()
{
intx,y;
cin>>x>>y;

cout<<"Maxis:";
process(x,y,max);

cout<<"Minis:";
process(x,y,min);

cout<<"Addis:";
process(x,y,add);

getch();
return0;
}

intmax(intx,inty)
{
returnx>y?x:y;
}

intmin(intx,inty)
{
returnx>y?y:x;
}

intadd(intx,inty)
{
returnx+y;
}

voidprocess(inti,intj,int(*p)(inta,intb))
{
cout<<p(i,j)<<endl;
}

‘贰’ 如何通过函数指针调用函数

一般需要定义一个函数指针类型

typedef int (*function_pointer_t) ( int arg1, int arg2 );

然后，定义函数指针变量

function_pointer_t fp_invoker = 0;

函数指针可以动态改变内容，改变调用对象，假设有两个函数

int function_sum( int arg1, int arg2 )
{
return arg1+arg2;
}
int function_sub( int arg1, int arg2 )
{
return arg1-arg2;
}

注意到两个函数的原型与函数指针类型是一致旦厅缓的。以下是调用

fp_invoker = function_sum; // 直接用函数名赋值即可
fp_invoker(1,2); // 调用时模模，可以认为函数指针便是函数名，此时调用加法
fp_invoker = function_sub; // 同理，切换到减法
fp_invoker(1,2); // 调用减法

以上都是直观的用法，通常函数指针用于回调，即下层函数先将函数指针内容保存起来，处理结束后，再调用。此时要注意首先检查函数指针内容是否为伏悉空。

if( fp_invoker ){
fp_invoker( arg1, arg2 );
}

‘叁’ C语言中函数指针用法

函数在内存中有一个物理位置，而这个位置是可以赋给一个指针的。一零点函数的地址就是该函数的入口点。因此，函数指针可被用来调用一个函数。函数的地址是用不带任何括号或参数的函数名来得到的。（这很类似于数组地址的得到方法，即，在只有数组名而无下标是就得到数组地址。）

怎样说明一个函数指针变量呢 ?

为了说明一个变量 fn_pointer 的类型是"返回值为 int 的函数指针", 你可以使用下面的说明语句：

int （*fn_pointer） （）；

为了让编译器能正确地解释这句语句， *fn_pointer 必须用括号围起来。若漏了这对括号， 则：

int *fn_pointer （）；

的意思完全不同了。fn_pointer 将是一个函数名， 其返回值为 int 类型的指针。

2：函数指针变量

在C语言中规定，一个函数总是占用一段连续的内存区， 而函数名就是该函数所占内存区的首地址。 我们可以把函数的这个首地址 （ 或称入口地址 ） 赋予一个指针变量， 使该指针变量指向该函数。然后通过指针变量就可以找到并调用这个函数。我们把这种指向函数的指针变量称为 " 函数指针变量 " 。

函数指针变量定义的一般形式为：

类型说明符 （* 指针变量名 ）（）；

其中 " 类型说明符 " 表示被指函数的返回值的类型。 "（* 指针变量名 ）" 表示 "*" 后面的变量是定义的指针变量。 最后的空括号表示指针变量所指的是一个函数。

例如： int （*pf）（）；

表示 pf 是一个指向函数入口的指针变量，该函数的返回值 （ 函数值 ） 是整型。

下面通过例子来说明用指针形式实现对函数调用的方法。

int max（int a,int b）

{

if（a>b）return a;

else return b;

}

main（）

{

int max（int a,int b）；

int（*pmax）（）；

int x,y,z;

pmax=max;

printf（"input two numbers:/n"）；

scanf（"%d%d",&x,&y）；

z=（*pmax）（x,y）；

printf（"maxmum=%d",z）；

}

从上述程序可以看出用，函数指针变量形式调用函数的步骤如下：

1>. 先定义函数指针变量，如后一程序中第 9 行 int （*pmax）（）； 定义 pmax 为函数指针变量。

2>. 把被调函数的入口地址 （ 函数名 ） 赋予该函数指针变量，如程序中第 11 行 pmax=max;

3>. 用函数指针变量形式调用函数，如程序第 14 行 z=（*pmax）（x,y）； 调用函数的一般形式为： （* 指针变量名 ） （ 实参表 ） 使用函数指针变量还应注意以下两点：

a. 函数指针变量不能进行算术运算，这是与数组指针变量不同的。数组指针变量加减一个整数可使指针移动指向后面或前面的数组元素，而函数指针的移动是毫无意义的。

b. 函数调用中 "（* 指针变量名 ）" 的两边的括号不可少，其中的 * 不应该理解为求值运算，在此处它只是一种表示符号。

3：指针型函数

前面我们介绍过，所谓函数类型是指函数返回值的类型。 在C语言中允许一个函数的返回值是一个指针 （ 即地址 ） ，这种返回指针值的函数称为指针型函数。

定义指针型函数的一般形式为：

类型说明符 * 函数名 （ 形参表 ）

{

…… /* 函数体 */

}

其中函数名之前加了 "*" 号表明这是一个指针型函数，即返回值是一个指针。类型说明符表示了返回的指针值所指向的数据类型。

如：

int *ap（int x,int y）

{

…… /* 函数体 */

}

表示 ap 是一个返回指针值的指针型函数， 它返回的指针指向一个整型变量。下例中定义了一个指针型函数 day_name ，它的返回值指向一个字符串。该函数中定义了一个静态指针数组 name 。 name 数组初始化赋值为八个字符串，分别表示各个星期名及出错提示。形参 n 表示与星期名所对应的整数。在主函数中， 把输入的整数 i 作为实参， 在 printf 语句中调用 day_name 函数并把 i 值传送给形参 n 。 day_name 函数中的 return 语句包含一个条件表达式， n 值若大于 7 或小于 1 则把 name[0] 指针返回主函数输出出错提示字符串 "Illegal day" 。否则返回主函数输出对应的星期名。主函数中的第 7 行是个条件语句，其语义是，如输入为负数 （i<0） 则中止程序运行退出程序。 exit 是一个库函数， exit（1） 表示发生错误后退出程序， exit（0） 表示正常退出。

应该特别注意的是函数指针变量和指针型函数这两者在写法和意义上的区别。如 int（*p）（） 和 int *p（） 是两个完全不同的量。 int（*p）（） 是一个变量说明，说明 p 是一个指向函数入口的指针变量，该函数的返回值是整型量， （*p） 的两边的括号不能少。

int *p（） 则不是变量说明而是函数说明，说明 p 是一个指针型函数，其返回值是一个指向整型量的指针，*p 两边没有括号。作为函数说明， 在括号内最好写入形式参数，这样便于与变量说明区别。 对于指针型函数定义，int *p（） 只是函数头部分，一般还应该有函数体部分。

main（）

{

int i;

char *day_name（int n）；

printf（"input Day No:/n"）；

scanf（"%d",&i）；

if（i<0） exit（1）；

printf（"Day No:%2d-->%s/n",i,day_name（i））；

}

char *day_n

ame（int n）

{

static char *name[]={ "Illegal day",

"Monday",

"Tuesday",

"Wednesday",

"Thursday",

"Friday",

"Saturday",

"Sunday"};

return（（n<1||n>7） ? name[0] : name[n]）；

}

本程序是通过指针函数，输入一个 1 ～ 7 之间的整数， 输出对应的星期名。指针数组的说明与使用一个数组的元素值为指针则是指针数组。指针数组是一组有序的指针的集合。指针数组的所有元素都必须是具有相同存储类型和指向相同数据类型的指针变量。

指针数组说明的一般形式为： 类型说明符 * 数组名 [ 数组长度 ]

其中类型说明符为指针值所指向的变量的类型。例如： int *pa[3] 表示 pa 是一个指针数组，它有三个数组元素， 每个元素值都是一个指针，指向整型变量。通常可用一个指针数组来指向一个二维数组。 指针数组中的每个元素被赋予二维数组每一行的首地址，因此也可理解为指向一个一维数组。图 6—6 表示了这种关系。

int a[3][3]={1,2,3,4,5,6,7,8,9};

int *pa[3]={a[0],a[1],a[2]};

int *p=a[0];

main（）

{

int i;

for（i=0;i<3;i++）

printf（"%d,%d,%d/n",a[i][2-i],*a[i],*（*（a+i）+i））；

for（i=0;i<3;i++）

printf（"%d,%d,%d/n",*pa[i],p[i],*（p+i））；

}

本例程序中， pa 是一个指针数组，三个元素分别指向二维数组 a 的各行。然后用循环语句输出指定的数组元素。其中 *a[i] 表示 i 行 0 列元素值； *（*（a+i）+i） 表示 i 行 i 列的元素值； *pa[i] 表示 i 行 0 列元素值；由于 p 与 a[0] 相同，故 p[i] 表示 0 行 i 列的值； *（p+i） 表示 0 行 i 列的值。读者可仔细领会元素值的各种不同的表示方法。 应该注意指针数组和二维数组指针变量的区别。 这两者虽然都可用来表示二维数组，但是其表示方法和意义是不同的

‘肆’ 如何定义指向函数的指针

一、定义一个函数指针的方法如下：

返回值类型 （* 指针变量名）（[形参列表]）;

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

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

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

二、函数指针的用法：

函数指针的应用：（*指针变量名）（参历罩数列表）

如：int c=(*ptr)(a,b);/* 函数指针 的使用*/

在C语言中，函数本身不是变量，但是可以定义指向函数的指针，也称作函数指针，函数指针指向函数的入口地址。这种类型的指针可以被赋值、存放在数组中、传递给函数以及作为函数的返回值等等。

(4)函数指针的使用方法扩展阅读：

指针函数和函数指针的区别：

1、这两个概念都是简称，指针岁让函数是指返回值是指针的函数，即本质是一个函数。我们知道函数都有返回类型（如果不返回值，则为无值型），只不过指针函数返回类型是某一类型的指针。

2、返回指针的函数的用途十分广泛。事实上，每一个函数，即使它不带有返回某种类乎烂局型的指针，它本身都有一个入口地址，该地址相当于一个指针。比如函数返回一个整型值，实际上也相当于返回一个指针变量的值，不过这时的变量是函数本身而已，而整个函数相当于一个“变量”。

‘伍’ c语言中指针怎么使用

1、使用场景

使用指针时，必须将它指向一个变量的地址或者为它分配空间方能使用，如下所示：

#include<stdio.h>

#include <stdlib.h>

int main(int argc, char const *argv[])

{

int a[5]={0,1,2,3,4};

int *b,*d;

int c=2;

int *e=a; //e指向a数组首地址

//*b=2; 无法直接初始化

//printf("%d ", *b);

e=e+2; //移动两个地址单元

d=&c; //d指向c的地址来表示值

c=4; //修改原c变量的值，d指针的值会发生改变

b=(int *)malloc(sizeof(int));//为b分配一个int型空间来直接存储值

*b=2;//分配空间后可以直接赋值了

printf("this is e,b,c,d :%d %d %d %d ",*e,*b,c,*d);

2、类型说明

（1）int *a :表示一个指向int型变量的指针，指向的是变量的地址单元

（2）char *b:表示一个指向char变量的指针

*a表示的是这个指针指向地址的值，a为此指针本身的地址，这点要明确，一般用*(a+1)、*(a+2)来表示值，如：

int nums[5]={0,1,2,3,4};

int *a=nums;

printf("%d %d %p ",*a,*(a+1),a);

(5)函数指针的使用方法扩展阅读：

指针的运算

指针指向变量地址，若原变量的内容发生了变化，它本身也会发生变化，指针之间的运算一般为值运算和地址运算

（1）值运算：直接通过*运算方式，像a+*(a+1),结果为第一个元素与第二个元素相加。

int nums[5]={0,1,2,3,4};

int *a=nums;

（2）地址运算：通过a+i的方式.指针会指向a的下i个地址。

int nums[5]={0,1,2,3,4};

int *a=nums;

a=a+2;

printf("%d ",*a);

结果输出2。

参考资料来源 ：指针-网络

‘陆’ 指向函数的指针用法

看完以下的，您就知道什么是指向函数的指针了，其实就是回调函数！

程序员常常需要实现回调。本文将讨论函数指针的基本原则并说明如何使用函数指针实现回调。注意这里针对的是普通的函数，不包括完全依赖于不同语法和语义规则的类成员函数（类成员指针将在另文中讨论）。

声明函数指针

回调函数是一个程序员不能显式调用的函数；通过将回调函数的地址传给调用者从而实现调用。要实现回调，必须首先定义函数指针。尽管定义的语法有点不可思议，但如果你熟悉函数声明的一般方法，便会发现函数指针的声明与函数声明非常类似。请看下面的例子：

void f()；// 函数原型

上面的语句声明了一个函数，没有输入参数并返回void。那么函数指针的声明方法如下：

void (*) ();

让我们来分析一下，左边圆括号中的星号是函数指针声明的关键。另外两个元素是函数的返回类型（void）和由边圆括号中的入口参数（本例中参数是空）。注意本例中还没有创建指针变量-只是声明了变量类型。目前可以用这个变量类型来创建类型定义名及用sizeof表达式获得函数指针的大小：

// 获得函数指针的大小
unsigned psize = sizeof (void (*) ());

// 为函数指针声明类型定义
typedef void (*pfv) ();

pfv是一个函数指针的自定义类型，它指向的函数没有输入参数，返回类行为void。使用这个类型定义名可以隐藏复杂的函数指针语法。

指针变量应该有一个变量名：

void (*p) (); //p是指向某函数的指针

p是指向某函数的指针，该函数无输入参数，返回值的类型为void。左边圆括号里星号后的就是指针变量名。有了指针变量便可以赋值，值的内容是署名匹配的函数名和返回类型。例如：

void func()
{
/* do something */
}
p = func;

p的赋值可以不同，但一定要是函数的地址，并且署名和返回类型相同。

传递回调函数的地址给调用者

现在可以将p传递给另一个函数（调用者）- caller()，它将调用p指向的函数，而此函数名是未知的：

void caller(void(*ptr)())
{
ptr(); /* 调用ptr指向的函数 */
}
void func();
int main()
{
p = func;
caller(p); /* 传递函数地址到调用者 */
}

如果赋了不同的值给p（不同函数地址），那么调用者将调用不同地址的函数。赋值可以发生在运行时，这样使你能实现动态绑定。

调用规范

到目前为止，我们只讨论了函数指针及回调而没有去注意ANSI C/C++的编译器规范。许多编译器有几种调用规范。如在Visual C++中，可以在函数类型前加_cdecl，_stdcall或者_pascal来表示其调用规范（默认为_cdecl）。C++ Builder也支持_fastcall调用规范。调用规范影响编译器产生的给定函数名，参数传递的顺序（从右到左或从左到右），堆栈清理责任（调用者或者被调用者）以及参数传递机制（堆栈，CPU寄存器等）。

将调用规范看成是函数类型的一部分是很重要的；不能用不兼容的调用规范将地址赋值给函数指针。例如：

// 被调用函数是以int为参数，以int为返回值
__stdcall int callee(int);

// 调用函数以函数指针为参数
void caller( __cdecl int(*ptr)(int));

// 在p中企图存储被调用函数地址的非法操作
__cdecl int(*p)(int) = callee; // 出错

指针p和callee()的类型不兼容，因为它们有不同的调用规范。因此不能将被调用者的地址赋值给指针p，尽管两者有相同的返回值和参数列。

‘柒’ 如何调用指针函数

1.如果是返回值是指针
char* getname()
{
char* pname=new char[23]; //返回指针必须是函数释放后并未释放的内存空型返间，
cout<<"input your name:\n"; //一般返回两种情况，一是在函数中像该函数一样动态分配堆内存
cin.getline(pname,22); //二是返回指针指向参数中地址，如： int* max(int a,int b) { return &a; }
pname[22]='\0';
return pname;
}
int main()
{
char* name=getname();
cout<<"your name is: "<<name<<endl;
delete []name; //记得动态释放分配内存
return 0;
}
2.参数是指针类型
常见的是通过指针或引用交换两个数的值
void swa(int* p1,int* p2)
{
int temp=*p1; *p1=*p2; *p2=temp;
}
int main()
{
int a=2,b=3;
swa(&a,&b); //传递地址
return 0;
}
附解：你可以把指针看做册租埋是一种复合类型，它之所以可以修改参数值，本质是因为
对指针解除引用*p形式是操作的参数所存数据内存空间，但如果它不解除引用，它
并不会修改参数的值：如
void swa(int* p1,int* p2) //函数意思是最初始在函数参数块中定义两个指针p1,p2，使
{ //p1指向a,p2指向b，下面函数体只是使指针指向地址改变，成了
//州蚂p1指向b，p2指向a。但并未对a,b内存空间操作，当函数调用结束后，指针p1,p2
//也释放了，所以并未起任何作用
int* temp;
temp=p1; p1=p2; p2=temp;
}
int main()
{
int a=2,b=3;
swa(&a,&b); //传递地址
cout<<a<<" "<<b;
return 0;
}
这个函数并不会交换a,b的值

‘捌’ c语言中函数指针是什么 有什么用 举个实例

函数指针是指向函数的指针变量。 因而“函数指针”本身首先应是指针变量，只不过该指针变量指向函数。这正如用指针变量可指向整型变量、字符型、数组一样，这里是指向函数。

函数指针有两个用途：调用函数和做函数的参数。

函数指针的声明方法为：

返回值类型 ( *指针变量名) ([形参列表]);

如：

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

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

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

或者使用下面的方法将函数地址赋给函数指针：

f = &func;

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

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

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

‘玖’ 怎样用函数指针 指向一个静态函数

C++指向函数的指针定义方式为：
返回类型
（*指针名）（函数参数列表），例如
void
（*p）（int）是指向一个返回值为void
参数为int类型的函数。
而若想定义一个指向类成员函数的函数指针该怎么定义呢？对成员函数指针的使用。
（1）非静态成员函数
定义方式：返回类型
（类名::*指针名）（函数参数列表）例如void
（A::*p）（int）是一个指向A类中成员函数的函数指针。
赋值方式：p=&A::函数名，而一般的函数指针的赋值是p=函数名即可，注意区别。（成员函数必须是public类型的）
调用方式：成员函数指针的调用必须通过类对象进行调用，a.*p(int)即可调用成员函数（该成员函数是public类型的）
（2）静态成员函数
对于静态成员函数的定义和使用方法都与普通函数指针的相同，只是在赋值的时候和非静态成员们函数指针的赋值方法相同。
因为静态成员函数的指针类型是与普通函数指针类型相同的。

‘拾’ 求指针函数的使用！！

1．函数指针定义

函数类型 （*指针变量名）(形参列表)；

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

例如：

int (*f)(int x);

double (*ptr)(double x);

在定义函数指针时请注意：

函数指针和它指向的函数的参数个数和类型都应该是—致的；

函数指针的类型和函数的返回值类型也必须是一致的。

2．函数指针的赋值

函数名和数组名一样代表了函数代码的首地址，因此在赋值时，直接将函数指针指向函数名就行了。

例如，

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

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

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

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

3．通过函数指针调用函数

函数指针是通过函数名及有关参数进行调用的。

与其他指针变量相类似，如果指针变量pi是指向某整型变量i的指针，则*p等于它所指的变量i；如果pf是指向某浮点型变量f的指针，则*pf就等价于它所指的变量f。同样地，*f是指向函数func(x)的指针，则*f就代表它所指向的函数func。所以在执行了f=func;之后，(*f)和func代表同一函数。

由于函数指针指向存储区中的某个函数，因此可以通过函数指针调用相应的函数。现在我们就讨论如何用函数指针调用函数，它应执行下面三步：

首先，要说明函数指针变量。

例如：int (*f)(int x);

其次，要对函数指针变量赋值。

例如： f=func; (func(x)必须先要有定义)

最后，要用 (*指针变量)(参数表);调用函数。

例如： (*f)(x);(x必须先赋值)

【例】任意输入n个数，找出其中最大数，并且输出最大数值。

main()

{

int f();

int i，a，b;

int (*p)(); /* 定义函数指针 */

scanf("%d"，&a);

p=f; /* 给函数指针p赋值，使它指向函数f */

for(i＝1;i<9;i++)

{
scanf("%d"，&b);

a＝(*p)(a，b); /* 通过指针p调用函数f */

}

printf("The Max Number is:%d"，a)

}

f(int x，int y)

{

int z;

z＝(x>y)?x:y;

return(z);

}

运行结果为：

343 -45 4389 4235 1 -534 988 555 789↙

The Max Number is：4389

【指针函数】

一个函数不仅可以带回一个整型数据的值，字符类型值和实型类型的值，还可以带回指针类型的数据，使其指向某个地址单元。

返回指针的函数，一般定义格式为：

类型标识符 *函数名(参数表)

int *f(x，y);

其中x，y是形式参数，f是函数名，调用后返回一个指向整型数据的地址指针。f(x，y)是函数，其值是指针。

如：char *ch();表示的就是一个返回字符型指针的函数，请看下面的例题：

【例】将字符串1(str1)复制到字符串2(str2)，并输出字符串2.

#include "stdio.h"

main()

{

char *ch(char *，char *);

char str1[]="I am glad to meet you!";

char str2[]="Welcom to study C!";

printf("%s"，ch(str1，str2));

}

char *ch(char *str1，char *str2)

{

int i;

char *p;

p=str2

if(*str2==NULL) exit(-1);

do

{

*str2=*str1;

str1++;

str2++;

}while(*str1!=NULL);

return(p);

}

通过分析可得

函数指针是一个指向函数的指针，而指针函数只是说明他是一个返回值为指针的函数，

函数指针可以用来指向一个函数。