C中的几组指针

1、二维数组

下面就三种二维数组进行说明。

   1: int **Ptr; 

   2: int *Ptr[ 5 ]; 

   3: int ( *Ptr )[ 5 ]; 

以上三例都是整数的二维数组，都可以用形如 Ptr[ 1 ][ 1 ] 的方式访问其内容；但它们的差别却是很大的。下面我从四个方面对它们进行讨论：

1.1、内容

它们本身都是指针，它们的最终内容都是整数。注意我这里说的是最终内容，而不是中间内容，比如你写 Ptr[ 0 ]，对于三者来说，其内容都是一个整数指针，即 int *；Ptr[ 1 ][ 1  ] 这样的形式才是其最终内容。

1.2、意义

   1: int **Ptr 表示指向"一群"指向整数的指针的指针。 

   2: int *Ptr[ 5 ] 表示指向 5 个指向整数的指针的指针。 

   3: int ( *Ptr )[ 5 ] 表示指向"一群"指向 5 个整数数组的指针的指针。 

1.3、所占空间

(1)、int **Ptr 和 (3)、int ( *Ptr )[ 5 ] 一样，在32位平台里，都是4字节，即一个指针。 
       (2)、int *Ptr[ 5 ] 不同，它是 5 个指针，它占5 * 4 = 20个字节的内存空间。

1.4、用法

   (1)、int **Ptr  
       因为是指针的指针，需要两次内存分配才能使用其最终内容。首先，Ptr = ( int ** )new int *[ 5 ]；这样分配好了以后，它和(2)的意义相同了；然后要分别对 5 个指针进行内存分配，例如： 
  Ptr[ 0 ] = new int[ 20 ]; 
  它表示为第 0 个指针分配 20 个整数，分配好以后， Ptr[ 0 ] 为指向 20 个整数的数组。这时可以使用下标用法 Ptr[ 0 ][ 0 ] 到Ptr[ 0 ][ 19 ] 了。 
      如果没有第一次内存分配，该 Ptr 是个"野"指针，是不能使用的，如果没有第二次内存分配，则 Ptr[ 0 ] 等也是个"野"指针，也是不能用的。当然，用它指向某个已经定义的地址则是允许的，那是另外的用法（类似于"借鸡生蛋"的做法），这里不作讨论（下同）。 
      (2)、int *Ptr[ 5 ] 
      这样定义的话，编译器已经为它分配了 5 个指针的空间，这相当于(1)中的第一次内存分配。根据对(1)的讨论可知，显然要对其进行一次内存分配的。否则就是"野"指针。 
      (3)、int ( *Ptr )[ 5 ] 
      这种定义我觉得很费解，不是不懂，而是觉得理解起来特别吃力，也许是我不太习惯这样的定义吧。怎么描述它呢？它的意义是"一群"指针，每个指针都是指向一个 5 个整数的数组。如果想分配 k 个指针，这样写： Ptr = ( int ( * )[ 5 ] ) new int[ sizeof( int ) * 5 * k ]。这是一次性的内存分配。分配好以后，Ptr 指向一片连续的地址空间， 
其中 Ptr[ 0 ] 指向第 0 个 5 个整数数组的首地址，Ptr[ 1 ] 指向第1 个 5 个整数数组的首地址。 
   综上所述，我觉得可以这样理解它们： 
   int ** Ptr <==> int Ptr[ x ][ y ]; 
   int *Ptr[ 5 ] <==> int Ptr[ 5 ][ x ]; 
   int ( *Ptr )[ 5 ] <==> int Ptr[ x ][ 5 ]; 
   这里 x 和 y 是表示若干的意思。

2、函数指针和指针函数

2.1、通常的函数调用

一个通常的函数调用的例子：

   1: void MyFun(int x);  //此处的申明也可写成：void MyFun( int ); 

   2: int main(int argc, char* argv[]) 

   3: { 

   4: MyFun(10);  //这里是调用MyFun(10);函数 

   5: return 0; 

   6: } 

   7: void MyFun(int x)  //这里定义一个MyFun函数 

   8: { 

   9: printf(“%d\n”,x); 

  10: } 

这个MyFun函数是一个无返回值的函数，它并不完成什么事情。这种调用函数的格式你应该是很熟悉的吧！看主函数中调用MyFun函数的书写格式： 
MyFun(10); 
我们一开始只是从功能上或者说从数学意义上理解MyFun这个函数，知道MyFun函数名代表的是一个功能（或是说一段代码）。 直到学习到函数指针概念时。我才不得不在思考：函数名到底又是什么东西呢？ 【js中函数】
（不要以为这是没有什么意义的事噢！呵呵，继续往下看你就知道了。）

2.2、函数指针变量的申明

就象某一数据变量的内存地址可以存储在相应的指针变量中一样，函数的首地址也以存储在某个函数指针变量里的。这样，我就可以通过这个函数指针变量来调用所指向的函数了。 
在C系列语言中，任何一个变量，总是要先申明，之后才能使用的。那么，函数指针变量也应该要先申明吧？那又是如何来申明呢？以上面的例子为例，我来申明一个可以指向MyFun函数的函数指针变量FunP。下面就是申明FunP变量的方法： 
void (*FunP)(int) ;  //也可写成void (*FunP)(int x); 
你看，整个函数指针变量的申明格式如同函数MyFun的申明处一样，只不过——我们把MyFun改成（*FunP）而已，这样就有了一个能指向MyFun函数的指针FunP了。（当然，这个FunP指针变量也可以指向所有其它具有相同参数及返回值的函数了。）

2.3、通过函数指针变量调用函数

有了FunP指针变量后，我们就可以对它赋值指向MyFun，然后通过FunP来调用MyFun函数了。看我如何通过FunP指针变量来调用MyFun函数的： （具体可参考C++ 虚函数表解析）

   1: void MyFun(int x);  //这个申明也可写成：void MyFun( int ); 

   2: void (*FunP)(int ); //也可申明成void(*FunP)(int x)，但习惯上一般不这样。 

   3: int main(int argc, char* argv[]) 

   4: { 

   5: MyFun(10);  //这是直接调用MyFun函数 

   6: FunP=&MyFun;  //将MyFun函数的地址赋给FunP变量 

   7: (*FunP)(20);  //这是通过函数指针变量FunP来调用MyFun函数的。 

   8: } 

   9: void MyFun(int x)  //这里定义一个MyFun函数 

  10: { 

  11: printf(“%d\n”,x); 

  12: } 

运行看看。嗯，不错，程序运行得很好。 

哦，我的感觉是：MyFun与FunP的类型关系类似于int 与int *的关系。函数MyFun好像是一个如int的变量（或常量），而FunP则像一个如int *一样的指针变量。 


int i,*pi; 


pi=&i;  //与FunP=&MyFun比较。


（你的感觉呢？） 


呵呵，其实不然—— 。。。。。

2.4、调用函数的其它书写格式

函数指针也可如下使用，来完成同样的事情：

   1: void MyFun(int x); 

   2: void (*FunP)(int );  //申明一个用以指向同样参数，返回值函数的指针变量。 

   3: int main(int argc, char* argv[]) 

   4: { 

   5: MyFun(10);  //这里是调用MyFun(10);函数 

   6: FunP=MyFun;  //将MyFun函数的地址赋给FunP变量 

   7: FunP(20);  //这是通过函数指针变量来调用MyFun函数的。 

   8: return 0; 

   9: } 

  10: void MyFun(int x)  //这里定义一个MyFun函数 

  11: { 

  12: printf(“%d\n”,x); 

  13: } 

运行试试，啊！一样地成功。 
咦？ 
FunP=MyFun; 
可以这样将MyFun值同赋值给FunP，难道MyFun与FunP是同一数据类型（即如同的int 与int的关系），而不是如同int 与int*的关系了？（有没有一点点的糊涂了？） 
看来与之前的代码有点矛盾了，是吧！所以我说嘛！ 
请容许我暂不给你解释，继续看以下几种情况（这些可都是可以正确运行的代码哟！）： 
代码之三：

   1: int main(int argc, char* argv[]) 

   2: { 

   3: MyFun(10);  //这里是调用MyFun(10);函数 

   4: FunP=&MyFun;  //将MyFun函数的地址赋给FunP变量 

   5: FunP(20);  //这是通过函数指针变量来调用MyFun函数的。 

   6: return 0; 

   7: } 

代码之四：

   1: int main(int argc, char* argv[]) 

   2: { 

   3: MyFun(10);  //这里是调用MyFun(10);函数 

   4: FunP=MyFun; //将MyFun函数的地址赋给FunP变量 

   5: (*FunP)(20); //这是通过函数指针变量来调用MyFun函数的。 

   6: return 0; 

7: }

真的是可以这样的噢！ 

   1: int main(int argc, char* argv[]) 

   2: { 

   3: （*MyFun）(10);  //看，函数名MyFun也可以有这样的调用格式 

   4: return 0; 

   5: } 

你也许第一次见到吧：函数名调用也可以是这样写的啊！（只不过我们平常没有这样书写罢了。） 
那么，这些又说明了什么呢？ 
呵呵！依据以往的知识和经验来推理本篇的“新发现”，我想就连“福尔摩斯”也必定会由此分析并推断出以下的结论： 
1. 其实，MyFun的函数名与FunP函数指针都是一样的，即都是函数指针。MyFun函数名是一个函数指针常量，而FunP是一个函数数指针变量，这是它们的关系。 
2. 但函数名调用如果都得如(*MyFun)(10)；这样，那书写与读起来都是不方便和不习惯的。所以C语言的设计者们才会设计成又可允许MyFun(10);这种形式地调用（这样方便多了并与数学中的函数形式一样，不是吗？）。 
3. 为统一起见，FunP函数指针变量也可以FunP(10)的形式来调用。 
4. 赋值时，即可FunP=&MyFun形式，也可FunP=MyFun。 
上述代码的写法，随便你爱怎么着！ 
请这样理解吧！这可是有助于你对函数指针的应用喽！ 
最后补充说明一点：在函数的申明处： 
void MyFun(int );  //不能写成void (*MyFun)(int )。 
void (*FunP)(int );  //不能写成void FunP(int )。 
（请看注释）这一点是要注意的。

2.5、定义某一函数的指针类型

就像自定义数据类型一样，我们也可以先定义一个函数指针类型，然后再用这个类型来申明函数指针变量。 
我先给你一个自定义数据类型的例子。

   1: typedef int* PINT;  //为int* 类型定义了一个PINT的别名 

   2: int main() 

   3: { 

   4: int x; 

   5: PINT px=&x;  //与int * px=&x;是等价的。PINT类型其实就是int * 类型 

   6: *px=10;  //px就是int*类型的变量 

   7: return 0; 

   8: } 

根据注释，应该不难看懂吧！（虽然你可能很少这样定义使用，但以后学习Win32编程时会经常见到的。） 
下面我们来看一下函数指针类型的定义及使用：（请与上对照！）

 1: void MyFun(int x);  //此处的申明也可写成：void MyFun( int ); 

   2: typedef void (*FunType)(int );  //这样只是定义一个函数指针类型 

   3: FunType FunP;  //然后用FunType类型来申明全局FunP变量 

   4: int main(int argc, char* argv[]) 

   5: { 

   6: //FunType FunP;  //函数指针变量当然也是可以是局部的 ，那就请在这里申明了。 

   7: MyFun(10); 

   8: FunP=&MyFun; 

   9: (*FunP)(20); 

  10: return 0; 

  11: } 

  12: void MyFun(int x) 

  13: { 

  14: printf(“%d\n”,x); 

  15: } 

首先，在void (*FunType)(int ); 前加了一个typedef 。这样只是定义一个名为FunType函数指针类型，而不是一个FunType变量。 

然后，FunType FunP;  这句就如PINT px;一样地申明一个FunP变量。 


其它相同。整个程序完成了相同的事。 


这样做法的好处是： 


有了FunType类型后，我们就可以同样地、很方便地用FunType类型来申明多个同类型的函数指针变量了。如下： 


FunType FunP2; 


FunType FunP3; 


//……

2.6、函数指针作为某个函数的参数

既然函数指针变量是一个变量，当然也可以作为某个函数的参数来使用的。所以，你还应知道函数指针是如何作为某个函数的参数来传递使用的。 
给你一个实例：
要求：我要设计一个CallMyFun函数，这个函数可以通过参数中的函数指针值不同来分别调用MyFun1、MyFun2、MyFun3这三个函数（注：这三个函数的定义格式应相同）。 【类似C#中delegate】
实现：代码如下：

1: void MyFun1(int x); 

   2: void MyFun2(int x); 

   3: void MyFun3(int x); 

   4: typedef void (*FunType)(int ); //②. 定义一个函数指针类型FunType,与①函数类型一至 

   5: void CallMyFun(FunType fp,int x); 

   6: int main(int argc, char* argv[]) 

   7: { 

   8: CallMyFun(MyFun1,10);  //⑤. 通过CallMyFun函数分别调用三个不同的函数 

   9: CallMyFun(MyFun2,20); 

  10: CallMyFun(MyFun3,30); 

  11: } 

  12: void CallMyFun(FunType fp,int x) //③. 参数fp的类型是FunType。 

  13: { 

  14: fp(x);//④. 通过fp的指针执行传递进来的函数，注意fp所指的函数是有一个参数的 

  15: } 

  16: void MyFun1(int x) // ①. 这是个有一个参数的函数，以下两个函数也相同 

  17: { 

  18: printf(“函数MyFun1中输出：%d\n”,x); 

  19: } 

  20: void MyFun2(int x) 

  21: { 

  22: printf(“函数MyFun2中输出：%d\n”,x); 

  23: } 

  24: void MyFun3(int x) 

  25: { 

  26: printf(“函数MyFun3中输出：%d\n”,x); 

  27: } 

输出结果：略 
分析：（看我写的注释。你可按我注释的①②③④⑤顺序自行分析。）

指针函数

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

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

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

int *f(x，y);

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

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

在C中函数返回值默认为int

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

 1: #include "stdio.h"

   2:  

   3: main()

   4:  

   5: {

   6:  

   7: char *ch(char *，char *);

   8:  

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

  10:  

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

  12:  

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

  14:  

  15: }

  16:  

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

  18:  

  19: {

  20:  

  21: int i;

  22:  

  23: char *p;

  24:  

  25: p=str2 

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

  27:  

  28: do

  29:  

  30: {

  31:  

  32: *str2=*str1;

  33:  

  34: str1++;

  35:  

  36: str2++;

  37:  

  38: }while(*str1!=NULL);

  39:  

  40: return(p);

  41:  

  42: }

通过分析可得

函数指针是一个指向函数的指针，而指针函数只是说明他是一个返回值为指针的函数，函数指针可以用来指向一个函数。

3、数组指针和指针数组

3.1、数组指针（也称行指针）

定义 int (*p)[n];
()优先级高，首先说明p是一个指针，指向一个整型的一维数组，这个一维数组的长度是n，也可以说是p的步长。也就是说执行p+1时，p要跨过n个整型数据的长度。

如要将二维数组赋给一指针，应这样赋值：

   1: int a[3][4];

   2: int (*p)[4]; //该语句是定义一个数组指针，指向含4个元素的一维数组。

   3:  p=a;        //将该二维数组的首地址赋给p，也就是a[0]或&a[0][0]

   4:  p++;       //该语句执行过后，也就是p=p+1;p跨过行a[0][]指向了行a[1][]

所以数组指针也称指向一维数组的指针，亦称行指针。

3.2、指针数组

定义 int *p[n];
[]优先级高，先与p结合成为一个数组，再由int*说明这是一个整型指针数组，它有n个指针类型的数组元素。这里执行p+1是错误的，这样赋值也是错误的：p=a；因为p是个不可知的表示，只存在p[0]、p[1]、p[2]...p[n-1],而且它们分别是指针变量可以用来存放变量地址。但可以这样 *p=a; 这里*p表示指针数组第一个元素的值，a的首地址的值。
如要将二维数组赋给一指针数组:

   1: int *p[3];

   2: int a[3][4];

   3: for(i=0;i<3;i++)

   4: p[i]=a[i];

这里int *p[3] 表示一个一维数组内存放着三个指针变量，分别是p[0]、p[1]、p[2]。所以要分别赋值。

这样两者的区别就豁然开朗了，数组指针只是一个指针变量，似乎是C语言里专门用来指向二维数组的，它占有内存中一个指针的存储空间。指针数组是多个指针变量，以数组形式存在内存当中，占有多个指针的存储空间。
还需要说明的一点就是，同时用来指向二维数组时，其引用和用数组名引用都是一样的。
比如要表示数组中i行j列一个元素：
*(p[i]+j)、*(*(p+i)+j)、(*(p+i))[j]、p[i][j]