函数指针重定义（C++怎么定义一个指向函数的指针）
本文目录
- C++怎么定义一个指向函数的指针
- C语言函数指针定义
- 如何定义指向函数的指针
- 如何定义一个指向任何函数的指针
- 当函数参数为指针时,为什么要重新声明另一指针替代
- C语言文件指针重定义与间接寻址地址不同问题
- C++如何定义一个指向重载函数的指针
- 求指针函数的使用！！
C++怎么定义一个指向函数的指针
C++指向函数的指针定义方式为：
返回类型
（*指针名）（函数参数列表），例如
void
（*p）（int）是指向一个返回值为void
参数为int类型的函数。
而若想定义一个指向类成员函数的函数指针该怎么定义呢？对成员函数指针的使用。
（1）非静态成员函数
定义方式：返回类型
（类名::*指针名）（函数参数列表）例如void
（A::*p）（int）是一个指向A类中成员函数的函数指针。
赋值方式：p=&A::函数名，而一般的函数指针的赋值是p=函数名即可，注意区别。（成员函数必须是public类型的）
调用方式：成员函数指针的调用必须通过类对象进行调用，a.*p(int)即可调用成员函数（该成员函数是public类型的）
（2）静态成员函数
对于静态成员函数的定义和使用方法都与普通函数指针的相同，只是在赋值的时候和非静态成员们函数指针的赋值方法相同。
因为静态成员函数的指针类型是与普通函数指针类型相同的。
C语言函数指针定义
在最上面加一句这样的定义
typedef void*(*pFn)();
pFn可以这样理解:首先pFn是一个指针,指针指向一个函数(或者说pFn是一个函数指针)，此函数返回一个无类型的指针。最终定义的变量及函数都是指针罢了，不过是指针的类型不同。所以在编译时会有警告，说指针类型不匹配。但对于程序来讲，都是可以在特定的上下文中使用的。
运行结果是
t1,t2交替出现。
其实void也可以换为其它的类型如int, double等
又想到一个很好的办法：
这次编译不会有警告，运行也不会出错。
示例代码如下所示
#include 《stdio.h》
long t1();
long t2();
int main()
{
long(*fn)()= (long (*)()) t1 ;
while(1){
fn = (long (*)()) fn();
}
}
long t1()
{
printf("t1\n");
return (long)t2 ;
}
long t2()
{
printf("t2\n");
return (long)t1 ;
}
如何定义指向函数的指针
这个用typedef可以完成：
先定义一个函数指针的类型：typedef
void
(*pfun)()；
然后用这个类型pfun定义一个数组
pfun
ptr里的数字是数组元素的个数，依情况而定：这儿用5做例子
这样ptr就是一个指向函数指针的数组。
对于“把一个指针强制定义”这我还没听过这个说法，只听过把指针强制转换成某个类型的指针：
强制类型转换用()运算，仍然用上面的定义类型。
例如：
void
*p;//p是一个void指针
pfun
ptr;//ptr是一个指向void函数的指针
ptr=(pfun)p；//把p强制转换成指向void函数的指针，然后就可以把它赋值给ptr指针。
不用typedef也可以，只要合并就可以了：
void
(*ptr)();//这样ptr就是一个函数指针数组了.这样看很费解的！不如用typedef。
对于强制类型转换最好还是用typedef，那样可读性好。
而且个人认为指针没有那种基本类型(指向函数的指针类型)，那是一种新的类型。所以要先定义那种类型才行。
用typedef定义新类型又没有什么副作用，而且容易读懂，何必非要不用typedef呢？！没必要把简单的问题复杂化！！
程序代码的可读性是很重要的，写复杂的类型而不用typedef是很令人反感的！
如何定义一个指向任何函数的指针
(一) 用函数指针变量调用函数
可以用指针变量指向整形变量、字符串、数组、结构体、也可以指向一个函数。一个函数在编译时被分配一个入口地址。这个入口地址就称为函数指针。可以用一个指针变量指向函数，然后通过该指针变量调用此函数。用简单的数值比较为例：
1 #include 《stdio.h》
2 #include 《stdlib.h》
3
4 int main()
5 {
6 int max(int,int);
7 int (*p)(int,int);
8 int a,b,c;
9 p = max;
10 scanf("%d,%d",&a,&b);
11 c = (*p)(a,b);
12 printf("a=%d,b=%d,max=%d\n",a,b,c);
13 return 0;
14 }
15
16 int max(int x,int y)
17 {
18 int z;
19 if(x》y) z = x;
20 else z = y;
21 return(z);
22 }
main函数中的" c = max(a,b); " 包括了一次函数的调用。每一个函数都占用一段内存单元。因此，可以用一个指针变量指向一个函数，通过指针变量来访问它指向的函数。
第7行：int （*p）( int,int ); 用来定义 p 是一个指向函数的指针变量，该函数有两个整形参数，函数值为整形。注意 *p 两侧的括号不可省略，表示 p 先与 * 结合，是指针变量，然后再与后面的 ( ) 结合，表示此指针变量指向函数，这个函数值 (即函数的返回值) 是整形的。如果写成 int *p ( int,int ) ,由于( )的优先级高于 *，它就成了声明一个函数P( 这个函数的返回值是指向整形变量的指针)。
赋值语句 p = max ; 作用是将函数 max 的入口地址赋给指针变量p。和数组名代表数组首元素地址类似，函数名代表该函数的入口地址。这时 p 就是指向函数 max 的指针变量，此时 p 和 max都指向函数开头，调用 *p 就是调用 max 函数。但是p作为指向函数的指针变量，它只能指向函数入口处而不可能指向函数中间的某一处指令处，因此不能用 *(p + 1)来表示指向下一条指令。
注意:
(1) 指向函数的指针变量的一般定义形式为：
数据类型 （*指针变量名）（函数参数列表）
这里数据类型就是函数返回值的类型
(2) int (* p) ( int,int ); 它只是定义一个指向函数的指针变量 p, 它不是固定指向哪一个函数的，而只是表示定义这样一个类型的变量，它是专门用来存放函数的入口地址的。在程序中把哪一函数(该函数的值应该是整形的，且有两个整形参数)的地址赋给它，他就指向哪一个函数。在一个函数中，一个函数指针变量可以先后指向同类型的不同函数。
(3) p = max; 在给函数指针变量赋值时，只需给出函数名而不必给出函数参数，因为是将函数的入口地址赋给 p ，而不涉及 实参和形参的结合问题，不能写成 p = max(a,b);
(4) c = (*p)(a,b) 在函数调用时，只需将( *p ) 代替函数名即可，后面实参依旧。
(5) 对于指向函数的指针变量，像 p++ ,p+n.....是无意义的。
(二) 用指向函数的指针作为函数参数
函数指针变量通常的用途之一就是把指针作为参数传递到其他函数。
函数的参数可以是变量、指向变量的指针变量、数组名、指向数组的指针变量，也可以是指向函数的指针也可以作为参数，以实现函数地址的传递，这样就能够在被调用的函数中使用实参函数。
void sub ( int ( *x1) (int), int (*x2) (int,int) )
{
int a,b,i,j;
a = (*x1)(i); /* 调用 f1 函数 */
b = (*x2)(i)(j); /* 调用 f2 函数 */
}
如果实参为两个 函数名 f1 和 f2. 在函数首部定义x1、x2为函数指针变量，x1指向的函数有一个整形形参，x2指向的函数有两个形参。i 和 j 是函数f1 和 f2所要的参数。函数sub的形参 x1、x2(指针变量)在函数 sub 未被调用时并不占用内存单元，也不指向任何函数。在sub被调用时，把实参函数 f1 和 f2的入口地址传给形式指针变量 x1 和 x2.
既然在 sub 函数中要调用 f1 和 f2 函数，为什么不直接调用f1 和 f2而要用函数指针变量呢? 确实，如果只是用到f1 和 f2 函数，完全可以在sub函数中直接调用f1 和 f2,而不必设指针变量 x1 和 x2。 但是,如果在每次调用sub时，调用的函数不是固定的，下次是f3 和 f4，再是f5 和 f6...这时用指针变量就比较方便了。
当函数参数为指针时,为什么要重新声明另一指针替代
因为原指针是不能改变的，如果你在函数内部对这个指针进行了修改；那么外部的数据也就被破坏了。比如
int a = "hello";
int *p_d = a;
void demo(void *p)
{
p++;
}
原本p_d指向的是a；
外部指针被修改了。
而如果函数是这个实现
void demo_1(void *p)
{
void *temp = p;
temp++;
}
修改了就是临时变量里的指针，而不会对外部输入的指针进行修改。
C语言文件指针重定义与间接寻址地址不同问题
p被重定义，把FILE** p;去掉，只留FILE* p;就行了。
调用函数fopen_s时是这样的 fopen_s(&p..........); //用&p当参数
如果定义FILE** p,然后直接用p当参数是会出问题的，因为p还没有被初始化，而fopen_s会写入*p,那10有89要出问题的
C++如何定义一个指向重载函数的指针
是的，由于指向函数的指针的类型是与函数的参数类型及数量还有返回类型相匹配的，所以一个函数指针只能指向重载函数的诸多版本中的一个版本。例如：
int func(int x); /* 声明一个函数 */
int func(int x,int y);/*重载函数*/
int (*f) (int x); /* 声明一个函数指针 */
f=func; /* 将func函数的首地址赋给指针f，此时f将指向第一个函数的地址而不是第二个函数 的地址*/
因为重载函数的多个函数体不仅地址不同，而且类型也不同。
求指针函数的使用！！
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);
}
通过分析可得
函数指针是一个指向函数的指针，而指针函数只是说明他是一个返回值为指针的函数，
函数指针可以用来指向一个函数。
