二维数组和指针
⑴ 用指针表示二维数组元素。
要用指针处理二维数组，首先要解决从存储的角度对二维数组的认识问题。我们知道，一个二维数组在计算机中存储时，是按照先行后列的顺序依次存储的，当把每一行看作一个整体，即视为一个大的数组元素时，这个存储的二维数组也就变成了一个一维数组了。而每个大数组元素对应二维数组的一行，我们就称之为行数组元素，显然每个行数组元素都是一个一维数组
下面我们讨论指针和二维数组元素的对应关系，清楚了二者之间的关系，就能用指针处理二维数组了。
设p是指向数组a的指针变量，若有：
p=a[0];
则p+j将指向a[0]数组中的元素a[0][j]。
由于a[0]、a[1]┅a[M-1]等各个行数组依次连续存储，则对于a数组中的任一元素a[i][j]，指针的一般形式如下：
p+i*N+j
元素a[i][j]相应的指针表示为：
*( p+i*N+j)
同样，a[i][j]也可使用指针下标法表示，如下：
p[i*N+j]
例如，有如下定义：
int a[3][4]={{10,20,30,40,},{50,60,70,80},{90,91,92,93}};
则数组a有3个元素，分别为a[0]、a[1]、a[2]。而每个元素都是一个一维数组，各包含4个元素，如a[1]的4个元素是a[1][0]、a[1][1]、a[1]2]、a[1][3]。
若有：
int *p=a[0];
则数组a的元素a[1][2]对应的指针为：p+1*4+2
元素a[1][2]也就可以表示为：*( p+1*4+2)
用下标表示法，a[1][2]表示为：p[1*4+2]
特别说明：
对上述二维数组a，虽然a[0]、a都是数组首地址，但二者指向的对象不同，a[0]是一维数组的名字，它指向的是a[0]数组的首元素，对其进行“*”运算，得到的是一个数组元素值，即a[0]数组首元素值，因此，*a[0]与a[0][0]是同一个值；
而a是一个二维数组的名字，它指向的是它所属元素的首元素，它的每一个元素都是一个行数组，因此，它的指针移动单位是“行”，所以a+i指向的是第i个行数组，即指向a[i]。对a进行“*”运算，得到的是一维数组a[0]的首地址，即*a与a[0]是同一个值。当用int *p;定义指针p时，p的指向是一个int型数据，而不是一个地址，因此，用a[0]对p赋值是正确的，而用a对p赋值是错误的。这一点请读者务必注意。
⑵ 用二维数组名作地址表示数组元素。
另外，由上述说明，我们还可以得到二维数组元素的另一种表示方法：
对于二维数组a，其a[0]数组由a指向，a[1]数组则由a+1指向，a[2]数组由a+2指向，以此类推。因此，*a与a[0]等价、*(a+1)与a[1]等价、*(a+2)与a[2]等价，┅，即对于a[i]数组，由*(a+i)指向。
由此，对于数组元素a[i][j]，用数组名a的表示形式为：
*(*(a+i)+j)
指向该元素的指针为：
*(a+i)+j
数组名虽然是数组的地址，但它和指向数组的指针变量不完全相同。指针变量的值可以改变，即它可以随时指向不同的数组或同类型变量，而数组名自它定义时起就确定下来，不能通过赋值的方式使该数组名指向另外一个数组。
例4 求二维数组元素的最大值。
该问题只需对数组元素遍历，即可求解。因此，可以通过顺序移动数组指针的方法实现。
main()
{
int a[3][4]={{3,17,8,11},{66,7,8,19},{12,88,7,16}};
int *p,max;
for(p=a[0],max=*p;p<a[0]+12;p++)
if(*p>max)
max=*p;
printf("MAX=%d/n",max);
}
执行结果：
MAX=88
这个程序的主要算法都是在for语句中实现的：p是一个int型指针变量；p=a[0]是置数组的首元素地址为指针初值；max=*p将数组的首元素值a[0][0]作为最大值初值；p<a[0]+12是将指针的变化范围限制在12个元素的位置内；p++使得每比较一个元素后，指针后移一个元素位置。
例5 求二维数组元素的最大值，并确定最大值元素所在的行和列。
本例较之上例有更进一步的要求，需要在比较的过程中，把较大值元素的位置记录下来，显然仅用上述指针移动方法是不行的，需要使用能提供行列数据的指针表示方法。
main()
{
int a[3][4]={{3,17,8,11},{66,7,8,19},{12,88,7,16}};
int *p=a[0],max,i,j,row,col;
max=a[0][0];
row=col=0;
for(i=0;i<3;i++)
for(j=0;j<4;j++)
if(*(p+i*4+j)>max)
{
max=*(p+i*4+j);
row=i;
col=j;
}
printf("a[%d][%d]=%d/n",row,col,max);
}
程序运行结果：
a[2][1]=88
⑶ 行数组指针
在上面的说明中我们已经知道，二维数组名是指向行的，它不能对如下说明的指针变量p直接赋值：
int a[3][4]={{10,11,12,13},{20,21,22,23},{30,31,32,33}},*p;
其原因就是p与a的对象性质不同，或者说二者不是同一级指针。
C语言可以通过定义行数组指针的方法，使得一个指针变量与二维数组名具有相同的性质。行数组指针的定义方法如下：
数据类型 (*指针变量名)[二维数组列数]；
例如，对上述a数组，行数组指针定义如下：
int (*p)[4];
它表示，数组*p有4个int型元素，分别为(*p)[0]、(*p)[1]、(*p)[2]、(*p)[3] ，亦即p指向的是有4个int型元素的一维数组，即p为行指针
此时，可用如下方式对指针p赋值：
p=a;
形如:
int a[10][10];
int (*p)[10];
这里要使指针p得到二维数组初始地址,要这样写---- p=a; 这里不难理解因为都属于二级的, p是指针型变量,指向一个包含5个元素的一维数组,故(*p)[10] 属二级指针
如:
int a[10];
int (*p)[10];
此时要取得a的首地址应该这样----p= &a; 因为一维数组相当于一级指针,a[10]的首地址是 a 第一个元素可这样取得
*a . 因为p属二级指针**p , 所以要取得数组首地址就应该这样写.
--------------------------------------------------
|
二维数组和指针
|
二维数组和指针
1、二维数组和数组元素的地址若有以下定义：int *p, a[3][4];
1）二维数组a由若干个一维数组组成在C语言中定义的二维数组实际上是一个一维数组，这个一维数组的每一个成员又是一个一维数组。如以上定义的a数组，则可视a数组由a[0]、a[1]、a[2]等三个元素组成，而a[0]、a[1]、a[2]等每个元素又分别是由4个整型元素组成的一维数组。可用a[0][0]、a[0][1]等来引用a[0]中的每个元素，其它依次类推。在第二节中已解释过，C语言中，在函数体中或在函数外部定义的一维数组名是一个地址常量，其值为数组第一个元素的地址，此地址的基类型就是数组元素的类型。在以上二维数组中，a[0]、a[1]、a[2]都是一维数组名，同样也代表一个不可变的地址变量，其值依次为二维数组每行第一个元素的地址，其基类型就是数组元素的类型。因此，对于二维数组，象a[0]++这样的表达式是非法的。若有表达式a[0]+1，表达式中1的单位应当是2个字节。在以上定义中，指针变量p的基类型与a[i]（0≤i＜3）相同，因此，赋值语句p=a[i]；是合法的。我们已知a[i]也可以写成：*(a+i),故以上赋值语句也可写成：p=*(a+i);。
2）二维数组名也是一个地址常量二维数组名同样也是一个存放地址常量的指针，其值为二维数组中第一个元素的地址。以上a数组，数组名a的值与a[0]的值相同，只是其基类型为具有4个整型元素的数组类型。即a+0的值与a[0]的值相同，a+1的值与a[1]的值相同，a+2的值与a[2]的值相同，它们分别表示a数组中第零、第一、第二行的首地址。二维数组名应理解为一个行指针。在表达式a+1中，数值1的单位应是4×2个字节，而不是2个字节。赋值语句p=a；是不合法的，因为p和a的基类型不同。同样，对于二维数组名a，也不可以进行a++,a=a+i等运算。
3）二维数组元素的地址二维数组元素的地址可以由表达式&a[i][j]求得；也可以通过每行的首地址来表示。以上二维数组a中，每个元素的地址可以通过每行的首地址：a[0]、a[1]、a[2]等来表示。如：地址&a[0][0]可以用a[0]+0来表示，地址&a[0][1]可以用a[0]+1表示；若0≤i＜3、0≤j＜4,则a[i][j]的地址可用以下五种表达式求得：（1）&a[i][j]（2）a[i]+j（3）*（a+i）+j（4）&a[0][0]+4*i+j （5）a[0]+ 4*i+j
在以上表达式中a[i]、&a[0][0]、a[0]的基类型都是int类型，系统将自动据此来确定表达式中常量1的单位是2个字节。但是不可以把求a[i][j]地址的表达式写成：a+4*i+j,因为a的基类型是4个整型元素的数组类型，系统将自动据此来确定常量1的单位是8个字节。
2、通过地址来引用二维数组元素若有以下定义：int a[3][4],i,j;且当0≤i＜3、0≤j＜4，则a数组元素可用以下五种表达式来引用：（1）a[i][j]（2）*(a[i]+j)（3）*(*(a+i)+j)（4）(*(a+i))[j]（5）*(&a[0][0]+4*i+j)
在(2)中，表达式*(a[i]+j)中，因为a[i]的基类型为int，j的位移量为2×j字节。
在(3)中，表达式*(*(a+i)+j)中，a的基类型为4个元素的数组，i的位移量为4×2×i字节；而*(a+i)的基类型为int，j的位移量仍为2×j字节。
在(4)中，*(a+i)外的一对圆括号不可少，若写成：*(a+i)[j]，因为运算符[]的优先级高于*号，表达式可转换成：*(*(a+i)+j)),即为：*(*(a+i+j)),这时i+j将使得位移量为4×2×（i+j）个字节，显示然这已不是元素a[i][j]的地址。*(*(a+i+j))等价于*(a[i+j])、等价于：a[i+j][0],引用的是数组元素a[i+j][0]，而不是a[i][j],很可能早已超出数组定义的范围。
在（5）中，&a[0][0]+4*i+j代表了数组元素a[i][j]的地址，通过间址运算符*号，表达式*(&a[0][0]+4*i+j)代表了数组元素a[i][j]的存储单元。
3、通过建立一个指针数组来引用二维数组元素若有以下定义：int *p[3], a[3][2], i,j ;在这里，说明符*p[3]中，也遵照运算符的优先级，一对[]的优先级高于*号，因此p首先与[]结合，构成p[3]，说明了p是一个数组名，系统将为它开辟3个连续的存储单元；在它前面的*号则说明了数组p是指针类型，它的每个元素都是基类型为int的指针。若满足条件：0≤i＜3,则p[i]和a[i]的基类型相同，p[i]= a[i]是合法的赋值表达式。
若有以下循环：for(i=0; i<3; i++) p[i]= a[i];在这里，赋值号右边的a[i]是常量，表示a数组每行的首地址，赋值号左边的p[i]是指针变量，循环执行的结果使p[0]、p[1]、p[2]分别指向a数组每行的开头。这时，数组p和数组a之间的关系如图9.6所示。
当p数组的每个元素已如图9.6所示指向a数组每行的开头时，则a数组元素a[i][j]的引用形式*（a[i]+ j）和*(p[i]+j)是完全等价的。由此可见，这时可以通过指针数组p来引用a数组元素，它们的等价形式如下：（1）*(p[i]+j) （2）*(*(p+i)+j) （3）(*(p+i))[j] （4）p[i][j] 不同的是：p[i]中的值是可变的，而a[i]中的值是不可变的。
图9.64、通过建立一个行指针来引用二维数组元素若有以下定义：int a[3][2], (*prt)[2];在这里，说明符(*prt)[2]中，由于一对圆括号的存在，所以*号首先与prt结合，说明prt是一个指针变量，然后再与说明符[2]结合，说明指针变量prt的基类型是一个包含有两个int元素的数组。在这里，prt的基类型与a的相同，因此prt=a;是合法的赋值语句。prt+1等价于a+1、等价于a[1]。当prt指向a数组的开头时，可以通过以下形式来引用a[i][j]：(1) *(prt[i]+j) (2) *(*(prt+i)+j) (3)(*(prt+i))[j] (4) prt[i][j] 在这里，prt是个指针变量，它的值可变，而a是一个常量。
附：
#include "stdio.h"
void disp(int (*a)[3])
{
printf("%d",*(*(a+1)+1));
}
void main()
{
int a[2][3];
a[0][0]=1;
a[0][1]=2;
a[0][2]=3;
a[1][0]=4;
a[1][1]=5;
a[1][2]=6;
disp(&a[0]);//也可以写作disp(a);
}