C语言中指针引用二维数组元素的问题
假设a是一个3行4列的二维数组，请问为什么a[0]与*(a+0)是等价的，我的理解是二维数组名a既然是该数组首元素的地址，那么（a+0）也是一个地址，“*（a+0）”就是...
假设a是一个3行4列的二维数组，请问为什么a[0]与*(a+0)是等价的，
我的理解是二维数组名a既然是该数组首元素的地址，那么（a+0）也是一个地址，“*（a+0）”就是指向“（a+0）”这个地址的内容（即首个元素值）。
a[0]与*(a+0)，一个元素地址和一个元素内容又如何能等价~~
请懂C语言的人帮忙解答，指出我的思维误区。我都为这问题冥思苦想好几天了，每次拿起书本就把该节内容看一边，就是不理解这了。
回答完了，加50分，我总共就100分。 展开
我的理解是二维数组名a既然是该数组首元素的地址，那么（a+0）也是一个地址，“*（a+0）”就是指向“（a+0）”这个地址的内容（即首个元素值）。
a[0]与*(a+0)，一个元素地址和一个元素内容又如何能等价~~
请懂C语言的人帮忙解答，指出我的思维误区。我都为这问题冥思苦想好几天了，每次拿起书本就把该节内容看一边，就是不理解这了。
回答完了，加50分，我总共就100分。 展开
展开全部
下面是本人文库中的文章，关于二维数组与指针的讲解。
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、注意，再次提示，数组的某行的行地址是与本行的第一个元素的地址是相同的。
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、注意，再次提示，数组的某行的行地址是与本行的第一个元素的地址是相同的。
已赞过
已踩过<
评论
收起
你对这个回答的评价是？
展开全部
二维数组名a是一个指向指针的指针。也是一个指针数组名，它含3个元素，a[0]a[1],a[2]。虽然a存储的地址是该数组首元素的地址，但它指向的并不是一个变量，而是一个指针。应为a是一个指向指针的指针，它指向的是和自己存储的地址相同的指针，即a[0],a[0]是第一行一维数组的指针，可以指向具体变量。
这下明白了吧，*（a+0）它不是变量，她是指针，a指向a[0],*(a+0)就是a[0].
这下明白了吧，*（a+0）它不是变量，她是指针，a指向a[0],*(a+0)就是a[0].
本回答被提问者采纳
已赞过
已踩过<
评论
收起
你对这个回答的评价是？
展开全部
首先你这是个二维数组，
那么 a可以想象成一个存储一维数组首地址的一维数组
+0是偏移量
那么a+0就是这个数组的第一个元素 *(a+0) 就是第一个元素的存储内容 即第一个一维数组的首地址
想必a[0]不用解释了
希望解答的正确明白
那么 a可以想象成一个存储一维数组首地址的一维数组
+0是偏移量
那么a+0就是这个数组的第一个元素 *(a+0) 就是第一个元素的存储内容 即第一个一维数组的首地址
想必a[0]不用解释了
希望解答的正确明白
已赞过
已踩过<
评论
收起
你对这个回答的评价是？
展开全部
呵呵，我也刚学到这个问题，和你分享一下吧，咋看之下，确实像你说的没错，但是这个“[]”运算符和“＊（）”运算符原来是一个意思的，是不是因为搬到二维数组就混淆了呀，我原来也是有同样的问题的。
你看看哪，要是搬回一维数组的话，我们知道a[0]与*(a+0)是相等的.
然后我们再回到二维数组讨论讨论，我认为既然a[][]是二维数组，（a+0）怎么看也不可能是二维吧，所以再用“星号”*去取里边的值，换是你，你该怎么取呢？所以呢，它们是相同的应该没错才对，是不是？
你看看哪，要是搬回一维数组的话，我们知道a[0]与*(a+0)是相等的.
然后我们再回到二维数组讨论讨论，我认为既然a[][]是二维数组，（a+0）怎么看也不可能是二维吧，所以再用“星号”*去取里边的值，换是你，你该怎么取呢？所以呢，它们是相同的应该没错才对，是不是？
已赞过
已踩过<
评论
收起
你对这个回答的评价是？
展开全部
“*（a+0）”就是指向“（a+0）”这个地址的内容,这是对的 但是他的内容也是一个地址，该地址指向一个一维数组，他的值与a[0]是相同的
至于数组中的元素 因为a是个指针的指针 想要引用元素 就必须两个解引用符号** 比如 **（a+0） 就是a[0][0]的值 类似的 *（*（a+1)+3)==a[1][3]
配合楼上的 你应该懂了吧
至于数组中的元素 因为a是个指针的指针 想要引用元素 就必须两个解引用符号** 比如 **（a+0） 就是a[0][0]的值 类似的 *（*（a+1)+3)==a[1][3]
配合楼上的 你应该懂了吧
已赞过
已踩过<
评论
收起
你对这个回答的评价是？
更多回答（7）
推荐律师服务：
若未解决您的问题，请您详细描述您的问题，通过百度律临进行免费专业咨询
