C提高——数组、数组数据类型、数组数据类型指针、多维数组本质等

数组

int main() {
    int a[200] = { 0 };


    printf("a=%d\n", a);
    printf("&a=%d\n", &a);

    printf("a+1=%d\n", a+1);
    printf("&a+1=%d\n", &a+1);
    system("pause");
}

对于一维数组，C语言规定：
a代表数组首元素的地址
&a代表整个数组的地址
数组的地址和数组首元素的地址是重叠的。

但两个指针的步长不一样，a+1的步长为4，&a+1的步长为200*4

数组（数据）类型

怎样定义一个指向数组 的 数据类型？
typedef int(MYARRAY)[5];// 定义了一个数组数据类型，相当于 int array[10];

    typedef int(MYARRAY)[5];// 定义了一个数组数据类型，相当于 int array[10];
    MYARRAY array;
    int len = sizeof(array);
    memset(array, 0, len);

    array[0] = 10;
    array[1] = 20;

    int i;
    for (i = 0; i<len / 4; i++){
        printf("%d\n", array[i]);
    }

    printf("array=%d\n", array);
    printf("&array=%d\n", &array);
    printf("array + 1=%d\n", array + 1);
    printf("&array + 1=%d\n", &array + 1);

    system("pause");
}

同上面数组一样：
array代表数组首元素的地址
&array代表整个数组的地址

数组指针（数据）类型

怎样定义一个指向数组指针的数据类型？
同数组（数据）类型类似：
typedef int(*pArray)[5];// 定义一个数组指针类型

数据指针类型变量

定义数组指针类型变量的三种方法：
一、通过声明的数组类型定义数组指针变量：

int main() {
    typedef int (MyArray)[5];// 声明一个数组类型
    MyArray *p;// 通过数组类型 定义 数组指针变量

    int arr[5] = { 0 };
    p=&arr;
    int i;

    for (i = 0; i < 5;i++){
        (*p)[i] = i + 10;
    }

    for (i = 0; i < 5; i++){
        printf("%d\n", (*p)[i]);
    }
    system("pause");
}

二、通过声明的数组指针类型定义变量：

int main() {
    typedef int (*pArray)[5];// 声明一个数组指针类型
    pArray p;// 定义一个数组指针类型变量，告诉编译器分配4个字节的内存（32位平台下）

    int arr[5] = { 0 };// 一维数组名相当于一级指针
    p=&arr;// 数组指针变量相当于一个二级指针
    int i;

    for (i = 0; i < 5;i++){
        (*p)[i] = i + 10;
    }

    for (i = 0; i < 5; i++){
        printf("%d\n", (*p)[i]);
    }
    system("pause");
}

三、直接定义

int main() {
    int (*p)[5];// 直接定义数组指针类型变量，，告诉编译器分配4个字节的内存（32位平台下）

    int arr[5] = { 0 };
    p=&arr;
    int i;

    for (i = 0; i < 5;i++){
        (*p)[i] = i + 10;
    }

    for (i = 0; i < 5; i++){
        printf("%d\n", (*p)[i]);
    }
    system("pause");
}

多维数组名的本质

int main() {

    int a[3][5];
    int i, j;
    int temp = 1;

    for (i=0; i < 3; i++) {
        for (j=0; j < 5; j++) {
            a[i][j] = temp++;
        }
    }

    // 直接使用二维数组名
    for (i = 0; i < 3; i++) {
        for (j = 0; j < 5; j++) {
            printf("%d ", a[i][j]);
        }
    }

    printf("\n");

    int(*p)[5];// 定义一个指向一维数组的指针变量
    p = a;
    // 使用指针变量
    for (i=0; i < 3; i++) {
        for (j=0; j < 5; j++) {
            printf("%d ", p[i][j]);
        }
    }

    printf("\n");

    printf("*a=%d\n", *a);
    printf("a=%d\n", a);
    printf("a+1=%d\n", a + 1);
    printf("&a=%d\n", &a);
    printf("&a+1=%d\n", &a + 1);

    printf("p=%d\n", p);
    printf("p+1=%d\n", p+1);

    system("pause");
}

从上图结果可知：
二维数组的地址&a、二维数组首行的地址a、二维数组首元素的地址*a的值是重合的。
a+1的步长是20，刚好等于第一行的长度5*4。指向二维数组的数组指针p的步长也是20，证明二维数组名相当于一维数组指针。
&a+1的步长是60，刚好是整个二维数据的长度15*4。

推演：
(a+i) 代表整个第i行的地址
*(a+i) 代表第i行首元素的地址
*(a+i)+j 代表第i行，第j列的地址，相当于&a[i][j]

总结：（多维数组名 a）的本质是 （一个指向一维数组的指针），a的步长就是单个行的长度。

数组 “[]” 和 指针“*”的转化推演

a[i] = *(a+i)的转化过程：
a[i]
—-> a[0 + i]： 第一步，加上0占位符
—->[a + i]：第二步用a替换占位符0
—-> *(a + i)：第三步将中括号改为小括号，并在前面加上*

a[i][j] = *( *(a + i) + j)的转化过程：
a[i][j]
—->a[0 + i][j]：第一步，加上0占位符
—->[a + i][j]：第二步，用a替换占位符0
—-> *(a + i)[j]：第三步，将中括号改为小括号，并在前面加上*
—->*(a + i)[0 + j]：第四步，加上0占位符
—->[*(a + i) + j]：第五步，用*(a + i)替换占位符0
—->*( *(a + i) + j)：第六步，将中括号改为小括号，并在前面加上*

二维数组做函数参数的退化问题

void printArr(int(*p)[5]) {
    int i, j;
    for (i = 0; i < 3; i++) {
        for (j = 0; j < 5; j++) {
            printf("%d ", p[i][j]);
        }
    }
}

int main() {

    int a[3][5];
    int i, j;
    int temp = 1;

    for (i=0; i < 3; i++) {
        for (j=0; j < 5; j++) {
            a[i][j] = temp++;
        }
    }

    printArr(a);

    system("pause");
}

多维数组做函数参数会退化为一个指向一维数组的指针。也就是说形参中的多维数组编译器会把它当成一个指向一维数组的指针处理。实参a和形参p的数据类型本质不一样。