1. 三维数组中的指针

上一节中我们讨论了指针与多维数组的联系，并且以一个二维数组举例，讨论了其关系。 你肯定不满足于一个二维数组的情况。现在，我们继续增加一下复杂度，讨论一个三维数组的情况。

#include <stdio.h>
int main()
{
    int S[2][5][10] = {
        {{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
        {10, 11, 12, 13, 14, 15, 16, 17, 18, 19},
        {20, 21, 22, 23, 24, 25, 26, 27, 28, 29},
        {30, 31, 32, 33, 34, 35, 36, 37, 38, 39},
        {40, 41, 42, 43, 44, 45, 46, 47, 48, 49}},

        {{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
        {10, 11, 12, 13, 14, 15, 16, 17, 18, 19},
        {20, 21, 22, 23, 24, 25, 26, 27, 28, 29},
        {30, 31, 32, 33, 34, 35, 36, 37, 38, 39},
        {40, 41, 42, 43, 44, 45, 46, 47, 48, 49}}
    };

    //  访问元素S[1][2][3]
    printf("S[1][2][3] = %d", *(*(*(S + 1) + 2) + 3));
    return 0;
}

让我们再分析一下，上面代码中表达式*(*(*(S + 1) + 2) + 3)是怎么一步步运算，最终的得到元素S[1][2][3]的值的。

2. 使用指针访问三维数组元素

由于这个式子比较长，我们按照优先级，从最内层括号开始，再依次计算。 将其拆分成一步一步地来分析。

S + 1;
*(S + 1);
*(S + 1) + 2;
*(*(S + 1) + 2);
*(*(S + 1) + 2) + 3;
*(*(*(S + 1) + 2) + 3);

2.1 Step1

S + 1：

1. S是一个类型为int[2][5][10]的数组。
2. 数组int[2][5][10]出现在表达式中，转换为int(*)[5][10]类型的指针。
3. int(*)[5][10]类型的指针加1，移动一个步长。指向S中第二个int[5][10]。

表达式结果S + 1为：类型为int(*)[5][10]的指针。

在图中使用箭头表示指针指向。

2.2 Step2

*(S + 1)

1. S + 1的结果为类型int(*)[5][10]的指针。
2. 对指针使用取值运算符，int(*)[5][10]转换为int[5][10]的数组。

表达式*(S + 1)结果为：类型为int[5][10]的数组。

在图中使用双横线表示其类型。

2.3 Step3

*(S + 1) + 2

1. *(S + 1)的结果为类型int[5][10]的数组。
2. 数组int[5][10]出现在表达式中，转为int(*)[10]类型的指针。
3. int(*)[10]类型的指针加2，移动两个步长。

表达式*(S + 1) + 2结果为：类型为int(*)[10]的指针。

2.4 Step4

*(*(S + 1) + 2)：

1. *(S + 1) + 2的结果为类型为int(*)[10]的指针。
2. 对指针使用取值运算符，int(*)[10]转换为int[10]的数组。

表达式*(*(S + 1) + 2)结果为：类型为int[10]的数组。

2.5 Step5

*(*(S + 1) + 2) + 3：

1. *(*(S + 1) + 2)的结果为类型int[10]的数组。
2. 数组int[10]出现在表达式中，转为int (*)类型的指针。
3. int *类型的指针加3，移动三个步长。

表达式*(*(S + 1) + 2) + 3结果为：类型为int(*)的指针。