设有以下定义： a[4][3]={1,2,3,4,5,6_

是萌萌的前辈呀

1 2 3

4 5 6

7 8 9

10 11 12

a[1][2]=6

A. prt类型为int [3]，prt+1指向a[1]的地址，要得到a[1][2]，解引用*(prt+1)类型为int，答应应该为(*(prt+1))[2];

另外，*(prt+1)[2]为10，ptr+1类型认为int [3]，取其[2]相当于将当前地址作为首地址再往后移2行；

B. p为一维指针，类型为int ，p+5刚好指向6处地址，执行一次解引用即可，*(p+5);

C.prt类型int [3],*prt类型为int，*prt+1指向2，再+2往后移2个int单位，指向4；

D.a为二维数组，a类型为int [3],a+1指向从第二行开始的二维数组，*(a+1)解引用，降维为一维，指向第二行，此时类型为int，+2即可指向6，因此答案正确；

编辑于 2018-05-14 09:08:42 回复(6)

可可岛

1. 拆分二维数组

int a[4][3] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };

拆分成：

int b[3] = {1, 2, 3 };

int c[3] = {4, 5, 6 };

int d[3] = {7, 8, 9 };

int e[3] = {10, 11, 12 };

2. 为何拆分？

以“b[3] = {1, 2, 3 }”为例：

b是数组第一个元素的地址，这里b相当于整型指针！上述b，c，d，e都是整型指针。

那么就有：a[4] = { b, c, d, e };

这是一个一维数组，其中的元素都是整型指针。

a是什么？是数组a中第一个元素b的地址！

根据上述这种理解，发现可以很方便的解出这道题。

3. 例题分析：AC选项

先看“int ( * prt)[3]=a”,相当于：

int b[3];

int *prt = &b;

即定义了一个指向“数组第一个元素的地址”的指针prt；

而从1,2分析来看，a表示的正是b的地址。所以，这里等价于：prt = a。

我们看AC选项，先把ptr都换成a。

A：* (( * prt+1)[2])

*a 即a[0]，也就是b；

( b+1) 表示元素2的地址，也就是a[0][1]的地址；

(b+1)[2] → *( (b+1) + 2 ) = *(b+3) = b[3]，越界了！其实就是c[0]，VS上验证过，输出也是4.

而答案提供的相当于*(b[3])，连数组元素都算不上！

注：下标和指针转化公式：*(a+n) = a[n]

C：( * prt+1)+2

( * a+1)+2 等价于(b+1) + 2 = b+3，是4的地址，也就是c[0]的地址；同样错误。

不过可以验证*(( * prt+1)+2)，输出为4.

5. B选项分析：* ( * (p+5))

int *p = a[0]，相当于int *p = b，遇到p直接用b替换就行了！

* (p+5)等价于b[5]，也就是c[2]，元素6，前面还多个*，所以这个错的也很明显。

6. D选项

下标和指针转化公式：*(a+n) = a[n]，这个正反都可以使用，而且很好用。

编辑于 2018-06-25 23:05:04 回复(1)

风雪夜归人™

int *[]是一个数组，此数组有内容确定，每个元素都是int*类型 int (*)[]一个指针变量。 int (*)[] 中的(*)是一个指向数组的指针，此数组有[]个int类型的元素

发表于 2018-07-26 10:50:54 回复(0)

牛客359148043号

明确：
a是int [3]类型指针；
a[0]是int类型指针；
*a=a[0]是int类型指针；

ptr定义为了int [3]类型的指针，赋值为a;
p定义为int类型的指针，赋值为a[0];

选项：
* (( * prt+1)[2]) : *prt是int类型指针即a[0]，( * prt+1)指向第一行第二个元素。( * prt+1)[2]表达式越界！

* ( * (p+5))：p是int类型指针，p+5即往后移动5个int，指向了第二行第3个元素， *(p+5)也就是第二行第3个元素a[1][2]=6。*(p+5)不能再解引用了， * ( * (p+5))表达式错误！

( * prt+1)+2： prt是int [3]类型指针，*prt是int类型指针，* prt+1指向第一行第二个元素， (*prt+1)+2指向4，即*((*prt+1)+2)=4

* ( * (a+1)+2)： a是int [3]类型指针，a+1即往后移动3个int，指向第二行第1个元素，* (a+1)是int类型指针，* (a+1)+2即再往后移动两个int，指向第二行第3个元素， * ( * (a+1)+2)=6

发表于 2022-08-24 11:01:58 回复(0)

宁洋

int main() {

int a[4][3]={1,2,3,4,5,6,7,8,9,10,11,12};
int (*prt)[3]=a, *p=a[0];

cout << prt << endl;
cout << *prt << endl;
cout << *p << endl;

cout << *prt+1 << endl;
cout << *(prt+1) << endl;

cout << (*prt+1)[2] << endl;
cout << *(prt+1)[2] << endl;
cout << *(p+5) << endl;
cout << *(* prt+1)+2 << endl;
cout << * ( * (a+1)+2) << endl;

return 0;

}

自己探索一下就会恍然大悟。

发表于 2021-10-31 15:32:21 回复(1)

踏浪逐行

数组元素 a[1][2] 可以表示为 *(*(a+1)+2) 或 prt[1][2] 或 p[5]，具体解释如下：

*(*(a+1)+2)：a+1 表示指向第二行的指针，*(a+1) 表示第二行的首元素指针，*(a+1)+2 表示第二行第三个元素的指针，*(*(a+1)+2) 表示第二行第三个元素的值。
prt[1][2]：prt 是指向 a 数组的指针，因此 prt+1 表示指向第二行的指针，prt[1] 表示第二行的首元素指针，prt[1]+2 表示第二行第三个元素的指针，prt[1][2] 表示第二行第三个元素的值。
p[5]：p 表示第一行的首元素指针，p+5 表示第二行第三个元素的指针，因此 p[5] 表示第二行第三个元素的值。

因此，a[1][2] 的值为 6。

发表于 2023-02-15 17:14:00 回复(0)

子涵同学很奈斯呀

上代码：

#include<stdio.h>

int main(){
    int a[4][3] = {1,2,3,4,5,6,7,8,9,10,11,12};
    int (*prt)[3] = a, *p = a[0];
        printf("( * prt)=%d\n",( *prt));
        printf("( * prt+1)=%d\n",( *prt+1));
        printf("( * prt+1)+2=%d\n",( *prt+1)+2);
        printf("*((*prt))=%d\n",*((*prt)));
        printf("*((*prt+1))=%d\n",*((*prt+1)));
        printf("*((*prt+3))=%d\n",*((*prt+3)));
        printf("*((*prt+1)+2)=%d\n",*((*prt+1)+2));

        printf(" (*(p+5))=%d\n", * (p+5));
//printf(" * ( * (p+5))=%d\n", * ( * (p+5)));//[Error] invalid type argument of unary '*' (have 'int')

        printf("(*(prt+1))[2]=%d\n",(*(prt+1))[2]);//6

        printf("*(prt+1)[2]=%d\n",*(prt+1)[2]);

}

发表于 2022-08-06 21:05:43 回复(0)