求c语言指针方式引用二维数组问题

C语言中指针引用二维数组元素的问题~

下面是本人文库中的文章，关于二维数组与指针的讲解。

1、两条基本准则：
a、首先要明白，指针运算符的作用，我用一言以概之，你在哪里使用都不会错。指针运算符*的作用是求出*后面所指地址里的值。因此只要*后面的变量表示的是一个地址就可以使用*运算符，来求出这个地址中的值，你不用管这个地址的表示形式是怎样的，只要是地址就可以使用*来求出地址中的值。

b、[ ]这个运算符的的运算法则是，把左侧的地址加上[ ]内的偏移量然后再求指针运算，注意有[ ]运算符的地方就有个隐含的指针，比如x[2]表示的就是将指针x偏移2个单位量后再求指针运算。也就说x[2]与*(x+2)是相等的。

2、对二维数组的讲解：
a、对一维数组地址的详细讲解：
比如一维数组a[5]，众所周知，一维数组的数组名a表示的是第一个元素a[0]的地址，也就是说数组名与&a[0]是等价的，因此数组名a的地址，并不是这个一维数组的数组的地址。那么&a，表示的又是什么呢？因为，a是一个一维数组，所以&a表示的就是这个一维数组的地址，也就是说&a中的地址是一个包含有4个元素的一维数组的地址。就好比int i中的&i，才表示的是这个变量i的地址一样。

b、对二维数组地址的讲解：
比如二维数组b[3][4]，我们首先从一维开始分析，众所周知b[0]，b[1]分别表示的是二维数组中第一行第一个元素和第二行第二个元素的地址，也就是说b[0]是与&b[0][0]等价的，b[1]是与&b[1][0]等介的。因此数组名就与&b[0]等介的，也就是说数组名表示的是二维数组中第一行所包含的一维数组的地址，说简单一点，就是说二维数组名是二维数组中第一行的行地址。因此二维数组名b所包含的地址中包含有二维数组中第二维中元素的个数的一维数组，也就是b的地址中包含一个含有4个元素的一维数组的地址(也就是所谓的数组的数组了)。

c、对二维数组中地址的相加运算的讲解：
同样以b[3][4]为例来讲解，在上面讲到b[0]表示的是&b[0][0]，因此对b[0]进行相加运算，比如b[0]+1，那么就将使地址偏移一个单位，也就是地址被偏移到了&b[0][1]处，也就是b[0]+1表示的是b[0][1]的地址。上面也讲到数组名b，表示的是一个一维数组的地址，因此对数组名进行偏移，比如b+1，则将使指针偏移一个一维数组的长度，也就是b+1，将是&b[1]的地址，因此b+1的地址，表示的是二维数组中第二行所包含的一维数组的地址，简单点就是第二行的行地址。
d、对二维数组的指针运算：
*b
在上面讲解过，因为b表示的是二维数组中第一行所包含的一维数组的地址，因此*b=*(b+0)=*(&b[0])=b[0]，所以*b表示的是二维数组中第一行第一个元素的地址，即*b=&b[0][0]，用语言来描术*(b+0)就是，把数组名的地址偏移0个单位，然后再求这个地址所包含的值。在二维数组中，这个值就是指的b[0]，因此这个值是与b[0][0]的地址相等的，结果就是*(b+0)与b是相等的，这在多维数组中是个怪现象，至少本人无法理解这是为什么。因为对同一个地址，进行指针运算得到了不同的结果，比如*b和*b[0]，因为b和b[0]都是相同的地址，但对他们进行指针运算却得到了不同的结果，*b得到了&b[0][0]的地址，而*b[0]得到了b[0][0]的值，这是对同一个地址进行指针运算却得到了不同的值，对于这个问题，无法理解。
*(b+1)和*(b+0)
对于*(b+1)也和*(b+0)是同样的道理，*(b+1)=b[1]。我们再来看*b[1]，因为*b[1]=*(b[1]+0)=*(&b[1][0])=b[1][0]，可以看出，这就是二维数组中第二行第一个元素的地址。
*(*(b+1)+1)
因为*(*(b+1)+1)=*(*(&b[1])+1)=*(b[1]+1)=*(&b[1][0]+1)=*(&b[1][1])=b[1][1]，语言描术就是，b+1使地址偏移到了二维数组中第二行所包含的一维数组的地址(或第二行的行地址)，然后再对这个行地址求指针(或求值)运算，因此就得到第二行第一个元素的地址，然后再对这个地址偏移一个单位，就得到第二行第二个元素的地址，再对这个地址进行指针运算，就得到了这个元素的值，即b[1][1]，其他的内容可以以止类推。
e、对二维数组的指针和[ ]的混合运算
在下面的指针和[ ]的混合计算中，要记住两点关键法则，记住了这两点在哪里计算都不会出错
a、对于像b[1]这样的地址，最好应表示为&b[1][0]再进行偏移计算，比如对于b[1]+1，这不是直接在对b[1]加1，也就是b[1]+1不等于b[2]，因为b[1]表示的是第二行行1个元素的地址，对其加1，应该表示的是第二行第二个元素的地址，也就是&b[1][1]，而b[2]则表示的是第二行第一个元素的地址，因此错误，所以在计算时应把b[1]转换为&b[1][0]之后，才能直接进行地址的偏移，也就是说b[1]+1=&b[1][0]+1=&b[1][1]，这样才能得到正确的结果，并且不会出错。
b、对于有小括号的地方，一定不要省略小括号。比如(&b[1])[1]与&b[1][1]将表示的是不同的结果，第二个是显然的，对于第一个(&b[1])[1]=*((&b[1])+1)=*(&b[1]+1)=*(&b[2])=b[2]，可以看到，表示的是第3行第1个元素的地址，因此这两个的结果是显然不一样的。因此对于(b+1)[1]这样的运算，不能省略小括号，即(b+1)[1]=(&b[1])[1]=*((&b[1])+1)=*(&b[1]+1)=*(&b[2])=b[2]，如果省略了小括号，则是(b+1)[1]=&b[1][1]，这将是不易发现的错误。因此这是两个完完全全不同的符案。
c、总结，指针和[ ]混合运算2点关键，
第1：应把是地址的[ ]运算，转换为地址的形式，比如b[1]应转换为&b[1][0]。因为只有这样才能进行直接的地址相加运算，即&b[1][0]+1=&b[1][1]，而b[1]+1不等于b[2]。

第2：有小括号的地方不能省略小括号，如(b+1)[1]=(&b[1])[1]=*((&b[1])+1)=*(&b[1]+1)=*(&b[2])=b[2]，也&b[1][1]是完全不同的。

(*(b+1))[1] ，(*b)[1]
最简单的理解方法为*(b+1)和语句b[1]等价，即(*(b+1))[1]和语句b[1][1]是相同的，也就是二组数组第2行第2个元素的值b[1][1]，理解方法2逐条解释，如上面的解释*(b+1)表示的是二维数组b的第二行第一个元素的地址，也就是b[1]，然后再与后面的[1]进行运算，就得到b[1][1]。或者(*(b+1))[1]=*((*(b+1))+1)=*(*(b+1)+1)这个语句上面解释过。同理(*b)[1]=b[0][1]

*(b+1)[1]：
计算方法1把[ ]分解为指针来计算：因为[ ]运算符高于指针，因此应先计算[ ]再计算指针，因为[1]表示的是把左侧的地址偏移1个单位，再求指针，因此(b+1)[1]=*((b+1)+1)，最后再计算一次指针运算，也就是*(b+1)[1]=**((b+1)+1)=**(b+2)=*(*(b+2))=*b[2]=b[2][0]，可以看到，最后表示的是b中第3行第一个元素的值。
计算方法2把指针化为[ ]来计算：*(b+1)[1]=*(&b[1])[1]=*(*(&b[1]+1))=**(&b[2])=*b[2]=b[2][0]，注意*((&b[1])[1])表达式中应把(&b[1])括起来，若不括起来，则[ ]运算符的优先级高于&运算符，因此(&b[1])[1]与&b[1][1]是不一样的，后一个表示的是第二行第二个元素的地址，而头一个(&b[1])[1]则表示的是，对b的第二行的行地址偏移1个单位后再求指针的结果，也就是*(&b[1]+1)=*(&b[2])=b[2]，所以性质是不一样的。
(*b+1)[2]
计算方法1化简[ ]运算符：(*b+1)[2]=*((*b+1)+2)=*(*b+3)=*(&b[0][0]+3)=*(&b[0][3])=b[0][3]，这里要注意*b表示的是b[0]=&b[0][0]，在计算时最好不要代入b[0]来计算，而应把b[0]转换为&b[0][0]后再计算，因为b[0]+3，很容易被错误的计算为b[3]，而实际上b[0]指向的是第一行第一个元素的地址，对其偏移3个单位应该是指向第一行第4个元素的地址，即&b[0][3]，而b[3]，则指向了第3行第1个元素的地址，这是不同的。
计算方法2化简*运算符：(*b+1)[2]=(b[0]+1)[2]=(&b[0][0]+1)[2]=(&b[0][1])[2]=*(&b[0][1]+2)=*(&b[0][3])=b[0][3]，注意，在计算过程中小括号最好不要省略，省略了容易出错，因为[ ]运算符的优先给更高，如果省略了，某些地方将无法计算。比如(&b[0][0]+1)[2]=(&b[0][1])[2]，如果省略掉括号，则成为&b[0][1][2]，这对于二维数组来讲，是无法计算的。
(*(b+1))[5]
计算方法：(*(b+1))[5]=(*(&b[1]))[5]=(b[1])[5]=*(b[1]+5)=*(&b[1][0]+5)=*(&b[1][5])=b[1][5]，结果等于第二行第6个元素的值。
f、注意，在二维或者多维数组中有个怪现象，比如对于多维数组a[n][m][i][j]，那么这些地址是相同的，即数组名a, a[0], a[0][0], a[0][0][0], &a[0][0][0][0]，都是相同的地址。而且对数组名依次求指针运算将得到，比如*a=a[0]，*a[0]=a[0][0], *a[0][0]=a[0][0][0], *a[0][0][0]=a[0][0][0][0]，可以看到，只有对最后这个地址求指针运算才真正得到了数组中的值，因此对数组名求指针运算，要得到第一个元素的值，应该****a，也就是对4维数组需要求4次指针运算。同样可以看到，对数组名进行的前三次指针运算的值都是相同的，即*a, **a, ***a和a的值都是&a[0][0][0][0]的值，这就是这个怪问题，按理说对地址求指针应该得到一个值，但对多维数组求指针，却得到的是同一个地址，只是这些地址所包含的内容不一样。

3、数组指针与二维数组讲解：

下面我们将以y[4]={1,2,3,4}这个一维数组为例来层层讲解，指针和数组的关系。
1、数组指针：
定义形式为：int (*p)[4];表示定义了一个指向多维数组的指针，即指针p指向的是一个数组，这个数组有4个元素，对这个指针p的赋值必须是有4个int元素的数组的地址，即只要包含有四个元素的数组的地址都能赋给指针p，不管这个数组的行数是多少，但列数必须为4。即int y[4],x[22][4];都可以赋给指针p。赋值方式为p=&y或p=x，对于&y和二维数组数组名前面已讲过，&y中的地址是一个包含有4个元素的一维数组的地址，二维数组名x也是一个含有4个元素的一维数组的地址，因此可以这样赋值。而这样赋值将是错误的p=y，或者p=x[0]; 因为y和x[0]的地址只包含一个元素，他们不包含一个数组，因此出错。
2．注意()必须有，如果没有的话则，int *p[4]；则是定义了一个指针数组，表示每个数组元素都是一个指针，即p[2]=&i;指向一个int型的地址，而*p[2]则表示p[2]所指向的元素的值。
3．初始化数组指针p：
a、当把int y[4]赋给指针p时p=y将是错误的，正确的方式为p=&y因为这时编译器会检查赋给指针p的元素是否是含有四个元素的数组，如果是就能正确的赋值，但语句p=y中的y代表的是数组y[4]第一行第一列的元素的地址也就是&y[0]的地址，因此y指向的地址只有一个元素，而指针p要求的是有4个元素的数组的地址，因此语句p=y将出错。而&y也表示的是一个地址，因为数组名y表示的是&y[0]的地址，因此&y=&(&y[0])。可以把&y理解为是数组y[4]的第一行的行地址，即&y包含了数组y[4]的第一行的所有元素，在这里&y包含有4个元素，因则p=&y才是正确的赋值方法，在这里要注意，数组的某行的行地址是第本行的第一个元素的地址是相同的。
b、把x[22][4]赋给指针p有几种方法，方法一：p=x；我们这样来理解该条语句，首先x[0]表示的是二维数组x[22][4]的第1行第一列元素的地址，这个地址包含一个元素，这是显而易见的，而数组名x也表示一个地址，但这个地址包含的是一个数组(即数组的数组)，这个数组是包含4个元素的数组，这4个元素就是数组x第一行的4个元素，也就是说x表示的是数组x[22][4]的第1行的行地址，即数组名x就包含了数组x[22][4]第1行的4个元素，因此这种赋值方式是正确的。这时指针p就相当于是数组名一样，比如p[2][1]访问的就是数组x的第3行的第2个元素。
c、方法二：p=x+1或者p=&x[1];注意必须要有地址运算符&，同理语句&x[1]表示的是数组x[22][4]第2行的行地址，因为x[1]表示的是数组x[22][4]第的第2行第1列的元素的地址，因此&x[1]表示的就是数组x的第2行的行地址，因为&x[1]这个地址包含了一个数组，这个数组的起始地址是从x[1]这个地址开始的，这，即数组x[22][4]中x[1]这一行的4个元素。在这一行中包含了4个元素。而x+1本身就是指的x[1]的地址。这时指针p的起始地址是&x[1]，所以p[0][1]不再是访问的x的第一行第二个元素，而是访问的x的第二行第二个元素。
d、注意，再次提示，数组的某行的行地址是与本行的第一个元素的地址是相同的。

在C语言中，实际上，没有真正的多维数组，只有一维数组

所谓的二维数组，只不过是，一个一维数组中，每个元素的类型，本身又是一维数组而已

因此，定义指向二维数组的指针，实际上，是定义一个指向包含多少个元素的一维数组的指针

比如：

int a[3][4];
int (*p)[4]; //定义一个指向包含4个元素的一维数组的指针
p=a; //指针p指向二维数组a

就按照你举的例子来说：
a[2][3]={0,1,2,3,4,5}
这时形成一个二维数组，元素是：
a[0][0]=0，物理地址&a[0][0]
a[0][1]=1，地址&a[0][0]+1
a[0][2]=2，地址&a[0][0]+2
a[1][0]=3，地址&a[0][0]+3
a[1][1]=4，地址&a[0][0]+4
a[1][2]=5，地址&a[0][0]+5
分配存储空间时，系统把每3个数据作为一组，组名记a[0]、a[1]，这两个值分别是每组第一个元素的地址，即a[0]=&a[0][0]，a[1]=&a[1][0]。
所以：
a指向数组首元素的地址，a=&a[0][0]；
a[0]代表第一组首元素地址，当然，a[0]也指向数组首元素的地址，a[0]=&a[0][0]；
*a是对a取值，它取出的是a[0]，当然=&a[0][0]；
&a[0]指a[0]的地址，还是它自己，所以&a[0]=&a[0][0]。
所以，第一行个打印语句输出的5个内容都是一样的，所以，输出5个19ff0c。是a[0][0]（元素0）的储存位置。
第二个打印语句输出的5个内容也是相同的，都是19ff18。它们是a[1][0]（元素3）的存放位置，19ff0C+3×4=19ff0c+12=19ff0c+c=19ff18。
后面也是类似解释。
具体p1、p2、p3的使用，是前面定义了三个字符串，此处拿来使用。你可以直接把p1的内容"%x,%x,%x,%x,%x\n"拿来替换掉p1，就好理解了。
有什么问题请留言。

我是这样理解的：

a是一个二维数组，也就是一个二级指针，那么a代表指向数组头的二级指针，*a代表指向数组头的一级指针，**a代表第一个数组元素。因为二维数组只是一维数组在内存地址上的连续表示，所以a和*a的区别在于它们的有效范围不同，分别是数组的两个维度的维数。

所以a和*a都是指向数组头的指针，它们都指向第一个元素，所以输出的地址相同。

证实：

#include <stdio.h>

int main()

{

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

    printf("%x, %x, %d
", a, *a, **a);

    return 0;

}

输出结果：

这个方法我们没学过，从开始就不知道原理了

---

余杭区17866634628： C语言用指针来表示二维数组的问题 - ？
謇垂二十： 你说要放到另外一个数组B中,但是没看到你定义新的数组,所以我就按我自己的理解做了. #include <stdio.h> #define ROWS 3 #define COLS 4 double copy_ptr(double *tar);//一个变量就够了//ROWS和COLS本来就是define的,全局 int ...

余杭区17866634628： 关于C语言中指针引用二维数组一些问题 - ？
謇垂二十： 您好,int arr【3】【3】,相当于int *arr【3】,即定义了一个指针数组,arr+1就是arr【1】【0】的地址,*arr+1,先计算*arr,就是arr【0】【0】的地址,然后加1,就是arr【0】【1】,所以和上一个地址相差了2*4个字节,就是8,最好一个,先得到arr的地址,再+1.这个是在原来用掉的内存后面加了一个char型的空间存放指针,1个字节,所以是010BFE24.

余杭区17866634628： C语言指向二维数组指针问题 - ？
謇垂二十： #include#define LENGTH 5 void main() {int i=0, j=0; int iArray[LENGTH][LENGTH]; int (*pArray)[LENGTH]; for (i=0; i { for (j=0; j { iArray[i][j] = i*LENGTH+j; printf(＂%d\t＂, i*LENGTH+j); } printf(＂\n＂); } printf(＂\nUse pArray\n\n＂); pArray = iArray; ...

余杭区17866634628： C中指针如何指向二维数组? - ？
謇垂二十： #include <stdio.h> int main() { int a[2][2] = {{1,2},{3,4}}; int (* p)[2] = a; int i,j; for(i = 0; i < 2; i++) { for(j = 0; j < 2; j++) { printf(＂%d\n＂,p[i][j]); } } return 0; } 注:VS2012编译通过 一般二维数组有三种形式:1、int **p; 2、int *p[ 2 ]; 3、int ( *p )[ 2] 按照楼主的代码应该选第3种,不懂可以追问我

余杭区17866634628： 学习c语言中的指向二维数组的指针问题? - ？
謇垂二十： 指向二维数组的多重指针不过是 n级间址 指向n-1级罢了 如此而已 n> int ***p你要想任何东西 的指向都是 两个之间的关系指针就是简单的指针 只是数据类型不同而已 所有的指针都一样 (作用)int a[5][5]; int **p;是指向一位数组的int a[5][5][5]

余杭区17866634628： C语言怎么用指针代替二维数组 - ？
謇垂二十： 1.设p是指向二维数组a[m][n]的指针变量,则有:int* p=a[0];//此时P是指向一维数组的指针.P++后,p指向 a[0][1].2.如果定义int (*p1)[n];p1=a;p1++后,p1指向a[1][0]; 则p+j将指向a[0]数组中的元素a[0][j].由于a[0]、a[1]┅a[M-1]等各个行数组...

余杭区17866634628： C语言,用指针输出二维字符串数组的问题 - ？
謇垂二十： 注意这行:pn=number[0]; 这样pn指向的只是number[0],也就是第一个字符串啦.所以scanf(＂%s＂,pn+i);全部写入的是number[0],导入最后 number[0] == ＂aaabcf＂ 所以会得到那样的输出结果.原意是不是想写这样?char number[40][40]; char **pn = number;

余杭区17866634628： c语言问题,用指针为一个二维数组赋值 - ？
謇垂二十： ptr=arr; 其实你这样赋值也是可以的,是没有问题的. 因为arr是二维数组的数组名,它(arr)本身就代表这个二维数组的第0行的地址. 问题关键不是出现在这里,而是在你程序的while循环语句中 while(scanf(＂%f＂, &ptr+i)&&i!=7) i++; 你这...

余杭区17866634628： 求C语言高手指点:请问如何指针定义二维数组?? 请用 **p ,(*P)[ ] ,*p[ ] 三种来进行指针定义 - ？
謇垂二十： int a[4][5],*p[4],i; //p表示指针数组 for( i=0;i<4;i++ )p[i]=a[i]; /*有了这个定义后,指针数组p中的每一个指针分别指向了二维数组a每一行的首地址,以后通过p就可以访问a */ 访问格式:p[i][j] , (*(p+i))[j] , *(*(p+i)+j) , *(p[i]+j) 都表是a[i][j] eg: p[1][1]=1...

余杭区17866634628： 二级C语言...关于指针与二维数组...谢谢？
謇垂二十： 这是一个数组与指针的问题. 这里告诉你,通过指针引用一个二维数组元素的方式: 第一种: 最简单的s【】【】; 第二种:*(s【n】+m) 表示第n行第m列元素; 第三中:*(*(s+n)+m) 表示第n行第m列元素. 看到这里,你应该知道,数组中的每个元素的指针是多少了吧. A是想将s【0】【0】的指针赋给p,同过上面的3种引用方式中,可以知道s【0】【0】的地址为&s[0][0], s[0]或则*s.所以A错误,C真确. k为一个指向 char 【3】的指针,而且p指针的类型是char ,不相同不可以.B错误.D中k,s的类型不一样,错误