函数指针是指向函数的指针，指针函数是指一个函数的返回值是一个指针，但下面的几道题还是感觉很迷惑。各位能否讲的详细点呢？

• (1) float(**def)[10]   def是什么？
• (2) double*(*gh)[10]   gh是什么？
• (3) double(*f[10])()   f是什么？
• (4) int*((*b)[10])    b是什么？

这样老感觉有点乱，有什么窍门可以记得并理解的清楚一点么？

======================

解答：

(1) def是一个指针, 指向的对象也是一个指针, 指向的指针最终指向的是10个float构成的数组.

(2) gh是指针, 指向的是10个元素构成的数组, 数组的元素是double*类型的指针.

(3) f是10个元素构成的数组, 每个元素是指针, 指针指向的是函数, 函数类型为无参数且返回值为double. 下面要讲的窍门的例子跟这个很类似.

(4) b是指针,指向的是10个元素构成的数组, 数组元素为int*类型的指针.

窍门如下:





如果我们碰到复杂的类型声明，该如何解析它？例如：

char (*a[3])(int);

a到底被声明为什么东东？指针？数组？还是函数？

分析时，从a 最接近（按运算符优先级）处开始。我们看到a最接近符号是[ ]——注意：*比[ ]的优先级低。a后既然有[ ]，那么a是数组，而且是包含3个元素的数组。

那这个数组的每个元素是什么类型呢？虽然数组a只含有a[0]、a[1]、a[2]三个元素，a[3]实际上已经越界，但在分析数组a的元素的类型时，我们正好需要形式上的元素a[3]。知道了a[3]的类型，就知道了a的元素的类型。 a[3]是什么类型？是指针，因为它的前面有*. 由此可知，数组a的元素是指针。

光说是指针还不够。对于指针，必须说出它指向的东东是什么类型。它指向的东东是什么，就看*a[3]是什么（a[3]是指针，它指向的东东当然是*a[3]）了。继续按优先级观察，我们看到*a[3]后面有小括号，所以可以肯定*a[3]是函数。即数组a的元素是指向函数的指针。

指向的是什么类型的函数？这很明显，是入参为int、返回值为char的类型的函数。

至此解析完毕。

按上述方法，再复杂的也可以一步步解析出来。

就像习武不是为了打人而是为了防身一样，我们了解上述方法是为了看懂别人写的复杂声明，而不是为了在实践中自己去构造这种复杂的东东。实在需要复杂声明时，可以用typedef替代一部分。例如上面语句可改成两句：

typedef char (*

FUN_PTR

)(int);


FUN_PTR

a[3];

这样就清晰多了。

此外，上面的分析方法还让我们对某些东西的本质更加清楚。比如，n维数组的本质都是一维数组。看个具体的例子：

int a[3][5];

这句声明的是一个包含3个元素的一维数组，其每个元素又是一个由5个int数构成的数组。我们不能理解为：a是一个包含5个元素的一维数组，其每个元素又是一个由3个int数构成的数组。为什么？还是按上面的方法分析，这里从略。

有的书上或网上提供"向右看,向左看"的方法, 其实缺乏通用性, 比如它不适用于对多维数组本质的分析. 而且这种方法掩盖了本质. 本质应该是按上面所讲的,根据运算符优先级逐层剥开.

==============================================================================

一、指针函数











当一个函数声明其返回值为一个指针时，实际上就是返回一个地址给调用函数，以用于需要指针或地址的表达式中。









格式：












类型说明符



*



函数名



(



参数







)





当然了，由于返回的是一个地址，所以类型说明符一般都是



int



。









例如：





int *GetDate();

int * aaa(int,int);




函数返回的是一个地址值，经常使用在返回数组的某一元素地址上。

int * GetDate(int wk,int dy);

main()

{

int wk,dy;

do

{

printf(Enter week(1-5)day(1-7)/n);

scanf(%d%d,&wk,&dy);

}

while(wk<1||wk>5||dy<1||dy>7);

printf(%d/n,*GetDate(wk,dy));

}

int * GetDate(int wk,int dy)

{

static int calendar[5][7]=

{

{1,2,3,4,5,6,7},

{8,9,10,11,12,13,14},

{15,16,17,18,19,20,21},

{22,23,24,25,26,27,28},

{29,30,31,-1}

};

return &calendar[wk-1][dy-1];

}





程序应该是很好理解的，子函数返回的是数组某元素的地址。输出的是这个地址里的值。

二、函数指针










指向函数的指针包含了函数的地址，可以通过它来调用函数。声明格式如下：












类型说明符



(*



函数名



)(



参数







)





其实这里不能称为函数名，应该叫做指针的变量名。这个特殊的指针指向一个返回整型值的函数。指针的声明必须和它指向函数的声明保持一致。









指针名和指针运算符外面的括号改变了默认的运算符优先级。如果没有圆括号，就变成了一个返回整型指针的函数的原型声明。









例如：





void (*fptr)();





把函数的地址赋值给函数指针，可以采用下面两种形式：





fptr=&Function;

fptr=Function;





取地址运算符



&



不是必需的，因为单单一个函数标识符就标号表示了它的地址，如果是函数调用，还必须包含一个圆括号括起来的参数表。









可以采用如下两种方式来通过指针调用函数：





x=(*fptr)();

x=fptr();





第二种格式看上去和函数调用无异。但是有些程序员倾向于使用第一种格式，因为它明确指出是通过指针而非函数名来调用函数的。下面举一个例子：

void (*funcp)();

void FileFunc(),EditFunc();

main()

{

funcp=FileFunc;

(*funcp)();

funcp=EditFunc;

(*funcp)();

}

void FileFunc()

{

printf("FileFunc/n");

}

void EditFunc()

{

printf("EditFunc/n");

}

程序输出为：





FileFunc

EditFunc

三、指针的指针










指针的指针看上去有些令人费解。它们的声明有两个星号。例如：






char ** cp;






如果有三个星号，那就是指针的指针的指针，四个星号就是指针的指针的指针的指针，依次类推。

当你熟悉了简单的例子以后，就可以应付复杂的情况了。当然，实际程序中，一般也只用到二级指针，三个星号不常见，更别说四个星号了。









指针的指针需要用到指针的地址。





char c='A';

char *p=&c;

char **cp=&p;





通过指针的指针，不仅可以访问它指向的指针，还可以访问它指向的指针所指向的数据。下面就是几个这样的例子：





char *p1=*cp;

// (&c)


char c1=**cp;





你可能想知道这样的结构有什么用？利用指针的指针可以允许被调用函数修改局部指针变量和处理指针数组。

void FindCredit(int **);

main()

{

int vals[]={7,6,5,-4,3,2,1,0};

int *fp=vals;

FindCredit(&fp);

printf(%d/n,*fp);

}

void FindCredit(int ** fpp)

{

while(**fpp!=0)

if(**fpp<0) break;

else (*fpp)++;

}

首先用一个数组的地址初始化指针



fp



，然后把该指针的地址作为实参传递给函数



FindCredit()



。



FindCredit()



函数通过表达式



**fpp



间接地得到数组中的数据。

为遍历数组以找到一个负值，



FindCredit()



函数进行自增运算的对象是调用者的指向数组的指针，而不是它自己的指向调用者指针的指针。语句



(*fpp)++



就是对形参指针指向的指针进行自增运算的。但是因为



*



运算符高于



++



运算符，所以圆括号在这里是必须的，如果没有圆括号，那么



++



运算符将作用于二重指针



fpp



上。

四、指向指针数组的指针










指针的指针另一用法旧处理指针数组。有些程序员喜欢用指针数组来代替多维数组，一个常见的用法就是处理字符串。

char *Names[]=

{

Bill,

Sam,

Jim,

Paul,

Charles,

0

};

main()

{

char **nm=Names;

while(*nm!=0) printf(%s/n,*nm++);

}

先用字符型指针数组



Names



的地址来初始化指针



nm



。每次



printf()



的调用都首先传递指针



nm



指向的字符型指针，然后对



nm



进行自增运算使其指向数组的下一个元素



(



还是指针



)



。注意完成上述认为的语法为



*nm++



，它首先取得指针指向的内容，然后使指针自增。









注意数组中的最后一个元素被初始化为



0



，



while



循环以次来判断是否到了数组末尾。具有零值的指针常常被用做循环数组的终止符。程序员称零值指针为空指针



(NULL)



。采用空指针作为终止符，在树种增删元素时，就不必改动遍历数组的代码，因为此时数组仍然以空指针作为结束。

算数运算符高于赋值符优先级

#include <stdio.h>

int main(){
    int sum = 10;

    sum += 30 + sum;
    printf("sum: %d\n", sum);   // 50

    sum = 10;
    sum = sum + 30 + sum;       // 50
    printf("sum: %d\n", sum);

    sum = 10;
    sum *= 30 + sum;
    printf("sum: %d\n", sum);   // 400

    sum = 10;
    sum = sum * (30 + sum);     // 400
    printf("sum: %d\n", sum);

    return 0;
}

C++ 运算符优先级列表