【c语言】数组指针，指针数字，二维数组，数组参数，指针参数，数组传参

顾宝根

已于 2023-05-27 21:57:21 修改

阅读量225

点赞数

文章标签： c语言数据结构算法

于 2023-05-27 20:07:12 首次发布

本文链接：https://blog.csdn.net/gubaogen0011/article/details/130904951

版权

余秋雨：“任何一个真实的人都会自觉不自觉地在心理上过着多种年龄相重迭的生活，没有这种重迭，生命就会失去弹性，很容易风干和脆折。”

BGM ：被遗忘的时光

    int arr[2][3] = {1,2,3,4,5,6};
    // 2-dimensional array : {{1,2,3}, {4,5,6}}
    int (*pArr) [2][3] = &arr;
    // pointer pointed to a array
    printf("%p\n", pArr);
    printf("%p\n", arr);
    int * element1 = *arr;
    // *arr解析到了该二维数组中的第一个元素，即代表了第一个数组的首元素首地址
    // 遍历第一个数组元素；
    int data1 = *(element1);
    // 第一个数组元素中的第一个元素
    int data2 = *(element1+1);
    int data3 = *(element1+2);
    printf("1st arr = %d %d %d\n", data1, data2, data3);
    // 同理解析该二维数组中第二个数组元素，并遍历
    int * element2 = *(arr+1);
    int data4 = *(element2);
    // 第二个数组元素中的第一个元素
    int data5 = *(element2+1);
    int data6 = *(element2+2);
    printf("2nd arr = %d %d %d\n", data4, data5, data6);

    printf("hello 2-dimensional array\n");
    return 0;

数组指针

int arr[3] = {0};

arr是这个数组的首元素的首地址，也是这个数组的地址（但arr具体是个什么东西我真搞不明白）

所谓指针数组是一个指向数组的指针，说白话实际是一个8内存空间，里面存了一个数组的地址

定义语法：

形如 int (*p) [3] = &arr ;

那这个p就是一个指向数组（数组元素类型为int，长度为3）的指针，占八个内存，里面存放了数组的地址

    int arr[2][3] = {1, 2, 3, 4, 5, 6};
    // 2-dimensional array : {{1,2,3}, {4,5,6}}
    int (*pArr)[2][3] = &arr;
    // pointer pointed to a array
    printf("%p\n", pArr);
    printf("%p\n", arr);

这里pArr就是指向arr

运行结果如下

指针数组

顾名思义，这是一个数组，其元素是指针

    int arr[3] = {1,2,3};
    int (*pointerToArray) [3] = &arr;
    int * pointerArray[4] = {pointerToArray,arr, arr+1, arr+2};
    printf("%d, %d, %d, %d\n", *pointerArray[0],
           *pointerArray[1],
           *pointerArray[2],
           *pointerArray[3]);
    printf("hello pointer array\n");
    return 0;

pointerToArray是一个数组指针

pointerArray[4]是一个数组，其元素类型是int *，长度为4

第一元素是数组指针，第二个元素是（？）指向arr首元素的指针，第三个是指向arr第二个元素的指针...

运行结果：

二维数组

通俗讲，二维数组里的元素是一维数组，其实也可以理解为是指针，因为通过指针即可以找到数组

    int arr[2][3] = {1,2,3,4,5,6};
    // 2-dimensional array : {{1,2,3}, {4,5,6}}

这个arr的长度是2，里面的元素类型是 int [3]，即长度为3，元素类型为int的数组

arr当然是这个二维数组的首元素的首地址，*arr即解析到了一个数组元素的数组名，sizeof以下看看大小：

    int arr[2][3] = {1,2,3,4,5,6};
    // 2-dimensional array : {{1,2,3}, {4,5,6}}
    printf("%d\n", sizeof *arr);
    printf("hello 2-dimensional array\n");

运行结果：

那自然 *arr是第一个数组元素的数组名，将其遍历

    int arr[2][3] = {1,2,3,4,5,6};
    // 2-dimensional array : {{1,2,3}, {4,5,6}}
    printf("%d\n", sizeof *arr);
    printf("%d\n", **arr);
    printf("%d\n", *((*arr)+1));
    printf("%d\n", *((*arr)+2));
    printf("hello 2-dimensional array\n");

运行结果：

一维数组传参

void test(int arr[]){
    printf("size = %d\n", sizeof arr);
}
int main() {
    int arr[5] = {0};
    test(arr);
    return 0;
}

运行结果：

所以传入的实参是一个指针，而不是长度为20的整个数组，而这个指针想想也猜的出来，肯定指向数字首元素

遍历一下：

void test(int arr[], int length){
    printf("size = %d\n", sizeof arr);
    for (int i = 0; i < length; ++i) {
        printf("%d\t", *(arr+i));
    }
}
int main() {
    int arr[5] = {1,2,3,4,5};
    test(arr, 5);
    return 0;
}

运行结果：

指针数组传参

void test(int **arr, int length) {
    // arr是 指向 一个指针的指针，即存放的是一个指针的地址
    printf("size = %d\n", sizeof arr);
    for (int i = 0; i < length; ++i) {
        printf("%p\n", *(arr+i));
        printf("%d\n", **(arr+i));
    }
}

int main() {
    int arr[3] = {1, 2, 3};
    int *pArr[3] = {arr, arr + 1, arr + 2};
    test(pArr, 3);
    return 0;
}

运行结果：

二维数组传参

void test(int arr[2][3], int length1, int length2) {
    printf("size of p = %d\n", sizeof arr);
    // traverse
    for (int i = 0; i < length1; ++i) {
        for (int j = 0; j < length2; ++j) {
            printf("%d\t", *(*(arr+i)+j));
        }
        printf("\n");
    }
}

int main() {
    int arr[2][3] = {{1, 2, 3},{4,5,6}};
    printf("%p\n", &arr);
    test(arr, 2, 3);
    return 0;
}

运行结果：

void test(int * arr) {
    printf("%d\t", *arr);
    printf("%d\t", *(arr+1));
    printf("%d\t", *(arr+2));
    printf("\n");
}

int main() {
    int arr[2][3] = {{1, 2, 3},
                     {4, 5, 6}};
    test(*arr);
    test(*(arr+1));
    return 0;
}

void test(int * arr[3]) {
    printf("size of arr = %d\n", sizeof arr);
    printf("%d\t", **arr);
    printf("%d\t", **(arr+1));
    printf("%d\t", **(arr+2));
    printf("\n");
}

int main() {
    int arr[2][3] = {{1, 2, 3},
                     {4, 5, 6}};
    int * pArr1[3] = {*arr, *arr + 1, *arr + 2};
    int * pArr2[3] = {*(arr+1), *(arr+1) + 1, *(arr+1) + 2};
    test(pArr1);
    test(pArr2);
    return 0;
}

void test(int (*pArr)[3]) {
    int * temp = pArr;
    printf("%d\t", *temp);
    printf("%d\t", *(temp+1));
    printf("%d\t", *(temp+2));
    printf("\n");
}

int main() {
    int arr[2][3] = {{1, 2, 3},
                     {4, 5, 6}};
    int (*temp)[3] = &(*arr);
    int (*temp2)[3] = &(*(arr+1));
    test(temp);
    test(temp2);
    return 0;
}

void test(int **arr) {
    printf("%d\n", *(*arr + 0));
    printf("%d\n", *(*arr + 1));
    printf("%d\n", *(*arr + 2));
    printf("%d\n", *(*(arr + 1) + 0));
    printf("%d\n", *(*(arr + 1) + 1));
    printf("%d\n", *(*(arr + 1) + 2));
}

int main() {
    int arr[2][3] = {{1, 2, 3},
                     {4, 5, 6}};
    printf("%d\n", *(*arr + 0));
    printf("%d\n", *(*arr + 1));
    printf("%d\n", *(*arr + 2));
    printf("%d\n", *(*(arr + 1) + 0));
    printf("%d\n", *(*(arr + 1) + 1));
    printf("%d\n", *(*(arr + 1) + 2));
    // test wrong!
//    test(arr);
    printf("hello int **\n");
    return 0;
}

void test(int * arr) {
    int * temp = arr;
    printf("%d\t", *(temp+0));
    printf("%d\t", *(temp+1));
    printf("%d\t", *(temp+2));
    printf("%d\t", *(temp+3));
    printf("%d\t", *(temp+4));
    printf("%d\t", *(temp+5));
    printf("\n");
}

int main() {
    int arr[2][3] = {{1, 2, 3},
                     {4, 5, 6}};
    test(&arr);
    printf("hello int **\n");
    return 0;
}

void test(int ** arr) {
    int * temp = arr;
    printf("%d\t", *(temp+0));
    printf("%d\t", *(temp+1));
    printf("%d\t", *(temp+2));
    printf("%d\t", *(temp+3));
    printf("%d\t", *(temp+4));
    printf("%d\t", *(temp+5));
    printf("\n");
}

int main() {
    int arr[2][3] = {{1, 2, 3},
                     {4, 5, 6}};
    test(&arr);
    printf("hello int **\n");
    return 0;
}

数组指针传参

void test(int (*pArr)[2][3], int length1, int length2) {
    printf("size of pArr = %d\n", sizeof pArr);
    int * temp = pArr;
    // traverse
    for (int i = 0; i < length1; ++i) {
        for (int j = 0; j < length2; ++j) {
            printf("%d\t", *(temp + (i * length2) + j));
        }
        printf("\n");
    }
}

int main() {
    int arr[2][3] = {{1, 2, 3},
                     {4, 5, 6}};
    printf("%p\n", &arr);
    test(arr, 2, 3);
    return 0;
}

运行结果：

数组指针是一个指向数组的指针
指针数组是一个数组，里面存放的元素是指针
二维数组是一个数组，里面存放的元素是一维数组

顾宝根

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
【c语言】数组指针，指针数字，二维数组，数组参数，指针参数，数组传参

arr是这个数组的首元素的首地址，也是这个数组的地址（但arr具体是个什么东西我真搞不明白）所谓指针数组是一个指向数组的指针，说白话实际是一个8内存空间，里面存了一个数组的地址定义语法：形如 int (*p) [3] = &arr;那这个p就是一个指向数组（数组元素类型为int，长度为3）的指针，占八个内存，里面存放了数组的地址这里pArr就是指向arr运行结果如下。
复制链接

扫一扫