指针数组与数组指针两者之前区别应用

　　数组指针(也称行指针)

　　定义 int (*p)[n];

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

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

　　int a[3][4];

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

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

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

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

　　指针数组

　　定义 int *p[n];

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

　　如要将二维数组赋给一指针数组:

　　int *p[3];

　　int a[3][4];

　　p++; //该语句表示p数组指向下一个数组元素。注：此数组每一个元素都是一个指针

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

　　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]

　　优先级：()>[]>*

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

　　一、指针数组和数组指针的内存布局

　　初学者总是分不出指针数组与数组指针的区别。其实很好理解：

　　指针数组：首先它是一个数组，数组的元素都是指针，数组占多少个字节由数组本身的大小决定，每一个元素都是一个指针，在32 位系统下任何类型的指针永远是占4 个字节。它是“储存指针的数组”的简称。

　　数组指针：首先它是一个指针，它指向一个数组。在32 位系统下任何类型的指针永远是占4 个字节，至于它指向的数组占多少字节，不知道，具体要看数组大小。它是“指向数组的指针”的简称。

　　下面到底哪个是数组指针，哪个是指针数组呢：

　　A)

　　int *p1[10];

　　B)

　　int (*p2)[10];

　　每次上课问这个问题，总有弄不清楚的。这里需要明白一个符号之间的优先级问题。

　　“[]”的优先级比“*”要高。p1 先与“[]”结合，构成一个数组的定义，数组名为p1，int *修饰的是数组的内容，即数组的每个元素。那现在我们清楚，这是一个数组，其包含10 个指向int 类型数据的指针，即指针数组。至于p2 就更好理解了，在这里“()”的优先级比“[]”高，“*”号和p2 构成一个指针的定义，指针变量名为p2，int 修饰的是数组的内容，即数组的每个元素。数组在这里并没有名字，是个匿名数组。那现在我们清楚p2 是一个指针，它指向一个包含10 个int 类型数据的数组，即数组指针。我们可以借助下面的图加深理解：

　　二、int (*)[10] p2-----也许应该这么定义数组指针

　　这里有个有意思的话题值得探讨一下：平时我们定义指针不都是在数据类型后面加上指针变量名么?这个指针p2 的定义怎么不是按照这个语法来定义的呢?也许我们应该这样来定义p2：

　　int (*)[10] p2;

　　int (*)[10]是指针类型，p2 是指针变量。这样看起来的确不错，不过就是样子有些别扭。其实数组指针的原型确实就是这样子的，只不过为了方便与好看把指针变量p2 前移了而已。你私下完全可以这么理解这点。虽然编译器不这么想。^_^

　　三、再论a 和&a 之间的区别

　　既然这样，那问题就来了。前面我们讲过a 和&a 之间的区别，现在再来看看下面的代码：

　　int main()

　　{

　　char a[5]={'A','B','C','D'};

　　char (*p3)[5] = &a;

　　char (*p4)[5] = a;

　　return 0;

　　}

　　上面对p3 和p4 的使用，哪个正确呢?p3+1 的值会是什么?p4+1 的值又会是什么?毫无疑问，p3 和p4 都是数组指针，指向的是整个数组。&a 是整个数组的首地址，a是数组首元素的首地址，其值相同但意义不同。在C 语言里，赋值符号“=”号两边的数据类型必须是相同的，如果不同需要显示或隐式的类型转换。p3 这个定义的“=”号两边的数据类型完全一致，而p4 这个定义的“=”号两边的数据类型就不一致了。左边的类型是指向整个数组的指针，右边的数据类型是指向单个字符的指针。在Visual C++6.0 上给出如下警告：

　　warning C4047: 'initializing' : 'char (*)[5]' differs in levels of indirection from 'char *'。

　　还好，这里虽然给出了警告，但由于&a 和a 的值一样，而变量作为右值时编译器只是取变量的值，所以运行并没有什么问题。不过我仍然警告你别这么用。

　　既然现在清楚了p3 和p4 都是指向整个数组的，那p3+1 和p4+1 的值就很好理解了。

　　但是如果修改一下代码，把数组大小改小点，会有什么问题?p3+1 和p4+1 的值又是多少呢?

　　int main()

　　{

　　char a[5]={'A','B','C','D'};

　　char (*p3)[3] = &a;

　　char (*p4)[3] = a;

　　return 0;

　　}

　　甚至还可以把代码再修改，把数组大小改大点：

　　int main()

　　{

　　char a[5]={'A','B','C','D'};

　　char (*p3)[10] = &a;

　　char (*p4)[10] = a;

　　return 0;

　　}

　　这个时候又会有什么样的问题?p3+1 和p4+1 的值又是多少?

　　上述几个问题，希望读者能仔细考虑考虑，并且上机测试看看结果。

　　测试结果:

　　(1).char (*p2)[5]=a;必须使用强制转换,如:char (*p2)[5]=(char (*)[5])a;

　　(2).把数组大小改变,都会编译不通过,提示:

　　error C2440: 'initializing' : cannot convert from 'char (*)[5]' to 'char (*)[3]'

　　error C2440: 'initializing' : cannot convert from 'char (*)[5]' to 'char (*)[10]'

　　(3).把以上程序测试代码如下:

　　int main()

　　{

　　char a[5]={'a','b','c','d'};

　　char (*p1)[5]= &a;

　　char (*p2)[5]=(char (*)[5])a;

　　printf("a=%dn",a);

　　printf("a=%cn",a[0]);

　　printf("p1=%cn",**p1);

　　printf("p2=%cn",**p2);

　　printf("p1+1=%cn",**(p1+1));

　　printf("p2+1=%cn",**(p2+1));

　　return 0;

　　}

　　输出:

　　a=1638208

　　a=a

　　p1=a

　　p2=a

　　p1+1=?

　　p2+1=?

　　Press any key to continue

　　结论:

　　根据指针类型及所指对象,表示指针大小,每次加1,表示增加指针类型大小的字节.----后面还会有解释说明.

　　四、地址的强制转换

　　先看下面这个例子：

　　struct Test

　　{

　　int Num;

　　char *pcName;

　　short sDate;

　　char cha[2];

　　short sBa[4];

　　}*p;

　　假设p 的值为0x100000。如下表表达式的值分别为多少?

　　p + 0x1 = 0x___ ?

　　(unsigned long)p + 0x1 = 0x___?

　　(unsigned int*)p + 0x1 = 0x___?

　　我相信会有很多人一开始没看明白这个问题是什么意思。其实我们再仔细看看，这个知识点似曾相识。一个指针变量与一个整数相加减，到底该怎么解析呢?

　　还记得前面我们的表达式“a+1”与“&a+1”之间的区别吗?其实这里也一样。指针变量与一个整数相加减并不是用指针变量里的地址直接加减这个整数。这个整数的单位不是byte 而是元素的个数。所以：p + 0x1 的值为0x100000+sizof(Test)*0x1。至于此结构体的大小为20byte，前面的章节已经详细讲解过。所以p +0x1 的值为：0x100014。

　　(unsigned long)p + 0x1 的值呢?这里涉及到强制转换，将指针变量p 保存的值强制转换成无符号的长整型数。任何数值一旦被强制转换，其类型就改变了。所以这个表达式其实就是一个无符号的长整型数加上另一个整数。所以其值为：0x100001。

　　(unsigned int*)p + 0x1 的值呢?这里的p 被强制转换成一个指向无符号整型的指针。所以其值为：0x100000+sizof(unsigned int)*0x1，等于0x100004。

　　上面这个问题似乎还没啥技术含量，下面就来个有技术含量的：在x86 系统下，其值为多少?

　　intmain()

　　{

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

　　int *ptr1=(int *)(&a+1);//指向a数组后面的内存单元，&a+1表示向后移16个存储单元

　　int *ptr2=(int *)((int)a+1);//表示a的存储单元的地址增加一个字节

　　printf("%x,%x",ptr1[-1],*ptr2);//ptr1[-1]其实指向的是a数组的最后一个单元，*ptr1则表示a数组的地址后移一个字节之后的4个连续存储单元所存储的值

　　return 0;

　　}

　　这是我讲课时一个学生问我的题，他在网上看到的，据说难倒了n 个人。我看题之后告诉他，这些人肯定不懂汇编，一个懂汇编的人，这种题实在是小case。下面就来分析分析这个问题：

　　根据上面的讲解，&a+1 与a+1 的区别已经清楚。

　　ptr1：将&a+1 的值强制转换成int*类型，赋值给int* 类型的变量ptr，ptr1 肯定指到数组a 的下一个int 类型数据了。ptr1[-1]被解析成*(ptr1-1)，即ptr1 往后退4 个byte。所以其值为0x4。

　　ptr2：按照上面的讲解，(int)a+1 的值是元素a[0]的第二个字节的地址。然后把这个地址强制转换成int*类型的值赋给ptr2，也就是说*ptr2 的值应该为元素a[0]的第二个字节开始的连续4 个byte 的内容。

　　其内存布局如下图：

　　好，问题就来了，这连续4 个byte 里到底存了什么东西呢?也就是说元素a[0],a[1]里面的值到底怎么存储的。这就涉及到系统的大小端模式了，如果懂汇编的话，这根本就不是问题。既然不知道当前系统是什么模式，那就得想办法测试。大小端模式与测试的方法在第一章讲解union 关键字时已经详细讨论过了，请翻到彼处参看，这里就不再详述。我们可以用下面这个函数来测试当前系统的模式。

　　int checkSystem()

　　{

　　union check

　　{

　　int i;

　　char ch;

　　} c;

　　c.i = 1;

　　return (c.ch ==1);//如果当前系统为大端模式这个函数返回0;如果为小端模式，函数返回1。

　　}

　　如果当前系统为大端模式这个函数返回0;如果为小端模式，函数返回1。也就是说如果此函数的返回值为1 的话，*ptr2 的值为0x2000000。如果此函数的返回值为0 的话，*ptr2 的值为0x100。

　　如果，您希望更容易地发现我的新博客，不妨点击一下绿色通道的【关注我】。(●'◡'●)

　　如果你觉得本篇文章对你有所帮助，请给予我更多的鼓励，求打 付款后有任何问题请给我留言!!!

　　因为，我的写作热情也离不开您的肯定支持，感谢您的阅读，我是【Jack_孟】!

　　分类: C语言

　　好文要顶 关注我 收藏该文

　　jack_Meng

　　关注 - 36

　　粉丝 - 1654

　　+加关注

　　46 1

　　« 上一篇： 什么是计算机科学

　　» 下一篇： 八卦基本知识

　　posted on 2013-10-22 16:44 jack_Meng 阅读(316588) 评论(10) 编辑 收藏

　　评论

　　#1楼

　　新人受教!

　　支持(0) 反对(0)

　　2015-08-05 16:03 | K_9527

　　#2楼

　　楼主辛苦了，不错!

　　支持(0) 反对(0)

　　2016-03-16 13:20 | willowind

　　#3楼

　　引用

　　如要将二维数组赋给一指针，应这样赋值：int a[3][4];

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

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

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

　　楼主这里第二行注释有个误区，将该二维数组的首地址赋给p，也就是a或&(a[0])

　　而不是a[0]或&a[0][0]吧?

　　支持(0) 反对(3)

　　2016-03-23 13:50 | Yosef Gao

　　#4楼

　　很详细，也讲得很透彻。顶

　　支持(1) 反对(0)

　　2016-04-11 19:47 | lei___lei

　　#5楼

　　@ Yosef Gao

　　引用

　　引用

　　引用如要将二维数组赋给一指针，应这样赋值：int a[3][4];

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

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

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

　　楼主这里第二行注释有个误区，将该二维数组的首地址赋给p，也就是a或&(a[0])

　　而不是a[0]或&a[0][0]吧?

　　在二维数组里面

　　a,&a,a[0],&a[0],&a[0][0]五个值是一样的，都指向二维数组的首地址(起始位置)

　　区别在于这五种表达方式的类型是不同的，以int a[2][3]举例：

　　a是二维数组名，是常量，存放着二维数组的首地址，类型为二维数组，sizeof(a)=24

　　&a 二维数组a的(首)地址，本身是一个指针，sizeof(&a)=4,指针类型都为4

　　a[0]指向二维数组中的第一行数组a[0][],类型是一维数组sizeof(a[0])=12

　　&a[0]代表a[0]的地址，与一维数组名a[0]值相同，但本身是指针类型sizeof(&a[0])=4

　　&a[0][0]表示二维数组中第一个元素的地址，指针类型sizeof(&a[0][0])=4

　　支持(0) 反对(0)

　　2016-04-19 11:26 | lize666

　　#6楼

　　是不是应该换成

　　毕竟假设了左边是低地址，右边是高地址对吧?

　　支持(0) 反对(1)

　　2016-04-25 17:22 | bjut13070010张骁

　　#7楼

　　我错了!!!!!

　　ptr1的值没有变，打印出的值ptr1[-1]的位置(ptr1-1)是上图的位置没错，但是ptr1的位置是没有变化的。

　　我错了!!!!!

　　支持(0) 反对(0)

　　2016-04-25 17:25 | bjut13070010张骁

　　#8楼

　　上面这个问题似乎还没啥技术含量，下面就来个有技术含量的：在x86 系统下，其值为多少?

　　intmain()

　　{

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

　　int *ptr1=(int *)(&a+1);//指向a数组后面的内存单元，&a+1表示向后移16个存储单元

　　int *ptr2=(int *)((int)a+1);//表示a的存储单元的地址增加一个字节

　　printf("%x,%x",ptr1[-1],*ptr2);//ptr1[-1]其实指向的是a数组的最后一个单元，*ptr1则表示a数组的地址后移一个字节之后的4个连续存储单元所存储的值

　　return 0;

　　}

　　这是我讲课时一个学生问我的题，他在网上看到的，据说难倒了n 个人。我看题之后告诉他，这些人肯定不懂汇编，一个懂汇编的人，这种题实在是小case。下面就来分析分析这个问题：

　　对于文中针对

　　“ printf("%x,%x",ptr1[-1],*ptr2);//ptr1[-1]其实指向的是a数组的最后一个单元，*ptr1则表示a数组的地址后移一个字节之后的4个连续存储单元所存储的值”

　　的注释不敢苟同。这个时候prt1应该是int*类型，也就是一个指向int类型的指针，注释却解释成“表示a数组的地址后移一个字节之后的4个连续存储单元所存储的值”?一个值和四个存储单元的值还是有区别的吧?