分类： C/C++
2009-12-02 09:52:02
函数指针定义时要注意,其函数返回值,参数等的类型要同他所要指向的函数相同．如 int (*pFuntion)(int i),则这个函数指针pFunction就只能指向返回类型为int,且函数的参数类型为int, 参数个数只有一个的函数．需要注意的是(*pFunction),括号必须,否则,将表示指针函数,即返回类型是int *,函数名字是pFunction的函数．
函数指针可以用来实现特殊的调用, 如,有一个公共的模块, 他要调用一个函数, 该函数的参数,返回类型都是固定的,但在不同的应用中函数体的具体实现是不一样的,此时就可以用一个函数指针来实现该函数的调用.如
void funtion(int i, int (*pF)(int ))
{
/*功能实现*/
.... /*函数调用*/ pF(i); /*功能实现*/ .....
}关键词：
以下均可以使用向右向左原则：
0。 指针与数组
int (*p)[4]; //定义一个指向（包含4个整数元素）的指针
int *p[4]; //定义一个指针数组，该指针数组包含4个（指向整形变量的指针）。
1。函数指针 与 指针函数
int (*p)(); //函数指针，也就是函数的入口地址
int *p()； //指针函数，也就是函数返回的值是一个指针。
2。函数指针
|
这里p被声明为一个函数指针，这个函数带一个char类型的参数，并且有一个int类型的返回值。
|
带有两个float类型参数、返回值是char类型的指针的指针的函数指针：
“右左法则”是一个简单的法则，但能让你准确理解所有的声明。这个法则运用如下：从最内部的括号（变量名）开始阅读声明，向右看，然后向左看。当你碰到一个括号时就调转阅读的方向。括号内的所有内容都分析完毕就跳出括号的范围。这样继续，直到整个声明都被分析完毕。
下面结合例子来演示一下“右左法则”的使用。
|
阅读步骤：
1. 从变量名开始——fp1
2. 往右看，什么也没有，碰到了)，因此往左看，碰到一个*——一个指针
3. 跳出括号，碰到了(int)——一个带一个int参数的函数
4. 向左看，发现一个*——（函数）返回一个指针
5. 跳出括号，向右看，碰到[10]——一个10元素的数组
6. 向左看，发现一个*——指针
7. 向左看，发现int——int类型
再来看一个例子：
|
阅读步骤：
1. 从变量名开始——arr
2. 往右看，发现是一个数组——一个5元素的数组
3. 向左看，发现一个*——指针
4. 跳出括号，向右看，发现()——不带参数的函数
5. 向左看，碰到*——（函数）返回一个指针
6. 跳出括号，向右发现()——不带参数的函数
7. 向左，发现*——（函数）返回一个指针
8. 继续向左，发现int——int类型
还有更多的例子：
|
指针函数和函数指针有什么区别
指针函数和函数指针有什么区别
1,这两个概念都是简称，指针函数是指带指针的函数，即本质是一个函数。我们知道函数都又返回类型（如果不返回值，则为无值型），只不过指针函数返回类型是某一类型的指针。其定义格式如下所示：
返回类型标识符 *返回名称（形式参数表）
{ 函数体 }
返回类型可以是任何基本类型和复合类型。返回指针的函数的用途十分广泛。事实上，每一个函数，即使它不带有返回某种类型的指针，它本身都有一个入口地址，该地址相当于一个指针。比如函数返回一个整型值，实际上也相当于返回一个指针变量的值，不过这时的变量是函数本身而已，而整个函数相当于一个“变量”。例如下面一个返回指针函数的例子：
#include
float *find();
main()
{
static float score[][4]={{60,70,80,90},{56,89,34,45},{34,23,56,45}};
float *p;
int i,m;
printf("Enter the number to be found:");
scanf("%d",&m);
printf("the score of NO.%d are:\n",m);
p=find(score,m);
for(i=0;i<4;i++)
printf("%5.2f\t",*(p+i));
}
float *find(float(*pionter)[4],int n)/*定义指针函数*/
{
float *pt;
pt=*(pionter+n);
return(pt);
}
学生学号从0号算起，函数find()被定义为指针函数，起形参pointer是指针指向包含4个元 素的一维数组的指针变量。pointer+1指向score的第一行。*(pointer+1)指向第一行的第0个元素。pt是一个指针变量，它指向浮点 型变量。main()函数中调用find()函数，将score数组的首地址传给pointer.
2,“函数指针”是指向函数的指针变量，因而“函数指针”本身首先应是指针变量，只不过该指针变量指向函数。这正如用指针变量可指向整型变量、字符型、数组一样，这里是指向函数。如前所述，C在编译时，每一个函数都有一个入口地址，该入口地址就是函数指针所指向的地址。有了指向函数的指针变量后，可用该指针变量调用函数，就如同用指针变量可引用其他类型变量一样，在这些概念上一致的。函数指针有两个用途：调用函数和做函数的参数。函数指针的说明方法为:
数据类型标志符 （*指针变量名）（参数）；注：函数括号中的参数可有可无，视情况而定。
下面的程序说明了函数指针调用函数的方法：
#include
int max(int x,int y){ return(x>y?x:y); }
void main()
{
int (*ptr)();
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是一个指针变量，不像函数名称那样是死的，它可以指向任何函数，就看你想怎么做了。在程序中把哪个函数的地址赋给它，它就指向哪个函数。而后用指针变量调用它，因此可以先后指向不同的函数，不过注意，指向函数的指针变量没有++和--运算，用时要小心。
函数指针
一：
#include
//定义一个指向有两个整型参数，返回值类型为void的函数指针类型compare
typedef void (*compare)(int e1, int e2);
void cmp(int e1, int e2)
{
printf("hello");
}
void main()
{
compare c = cmp; //定义一个函数指针对象c指向函数cmp
c(1,2); //调用
}
二：
#include
void test(void (*compare)(int e1, int e2)) //接收到cmp函数地址
{
//注意这里e1,e2对该作用域不可见
printf("yes");
compare(1, 2); //调用
}
void cmp(int e1, int e2)
{
printf("hello");
}
void main()
{
test(cmp); //把cmp地址传过去
}
关于C++中函数指针的使用(包含对typedef用法的讨论)
（一）简单的函数指针的应用。
//形式1：返回类型(*函数名)(参数表)
char (*pFun)(int);
char glFun(int a){ return;}
void main()
{
pFun = glFun;
(*pFun)(2);
}
第一行定义了一个指针变量pFun。首先我们根据前面提到的“形式1”认识到它是一个指向某种函数的指针，这种函数参数是一个int型，返回值是char类型。只有第一句我们还无法使用这个指针，因为我们还未对它进行赋值。
第二行定义了一个函数glFun()。该函数正好是一个以int为参数返回char的函数。我们要从指针的层次上理解函数——函数的函数名实际上就是一个指针，函数名指向该函数的代码在内存中的首地址。
然后就是可爱的main()函数了，它的第一句您应该看得懂了——它将函数glFun的地址赋值给变量pFun。main()函数的第二句中“*pFun”显然是取pFun所指向地址的内容，当然也就是取出了函数glFun()的内容，然后给定参数为2。
（二）使用typedef更直观更方便。
//形式2：typedef 返回类型(*新类型)(参数表)
typedef char (*PTRFUN)(int);
PTRFUN pFun;
char glFun(int a){ return;}
void main()
{
pFun = glFun;
(*pFun)(2);
}
typedef的功能是定义新的类型。第一句就是定义了一种PTRFUN的类型，并定义这种类型为指向某种函数的指针，这种函数以一个int为参数并返回char类型。后面就可以像使用int,char一样使用PTRFUN了。
第二行的代码便使用这个新类型定义了变量pFun，此时就可以像使用形式1一样使用这个变量了。
（三）在C++类中使用函数指针。
//形式3：typedef 返回类型(类名::*新类型)(参数表)
class CA
{
public:
char lcFun(int a){ return; }
};
CA ca;
typedef char (CA::*PTRFUN)(int);
PTRFUN pFun;
void main()
{
pFun = CA::lcFun;
ca.(*pFun)(2);
}
在这里，指针的定义与使用都加上了“类限制”或“对象”，用来指明指针指向的函数是那个类的这里的类对象也可以是使用new得到的。比如：
CA *pca = new CA;
pca->(*pFun)(2);
delete pca;
而且这个类对象指针可以是类内部成员变量，你甚至可以使用this指针。比如：
类CA有成员变量PTRFUN m_pfun;
void CA::lcFun2()
{
(this->*m_pFun)(2);
}
一句话，使用类成员函数指针必须有“->*”或“.*”的调用
“函数指针”是指向函数的指针变量，因而“函数指针”本身首先应是指针变量，只不过该指针变量指向函数。这正如用指针变量可指向整型变量、字符型、数组一样，这里是指向函数。C在编译时，每一个函数都有一个入口地址，该入口地址就是函数指针所指向的地址。有了指向函数的指针变量后，可用该指针变量调用函数，就如同用指针变量可引用其他类型变量一样，在这些概念上一致的。函数指针有两个用途：调用函数和做函数的参数。函数指针的说明方法为:
数据类型标志符 （*指针变量名）（参数）void (*ptr)(void)如果要定义函数指针数组：int (*FunList[ n ])() ：包含n个函数指针的数组
示例代码：
#include
int Fun0( int p0 )
{
printf( "Fun0 " );
printf( "Fun0----p0=[%d]---- ", p0 );
return 0;
}int Fun1( int p1 )
{
printf( "Fun1 " );
printf( "Fun1----p1=[%d]---- ", p1 );
return 1;
}
int main()
{
int i;
int nResult;
int (*FunList[ 2 ])() = { Fun0, Fun1 } ;printf( "input i:" );
scanf( "%d", &i );
while( 1 )
{
if ( i == -1 )
break;nResult = (*FunList[ i % 2 ])( i );
printf( "nResult:[%d] ", nResult );
printf( "input i:" );
scanf( "%d", &i );
}
printf( "the end! " );
// getch();
return 0;
}
