C语言进阶之指针数组指针及数组指针数组

原创已于 2025-06-18 16:42:48 修改 · 1k 阅读

12 ·

CC 4.0 BY-SA版权

文章标签：

#c语言 #算法 #linux #mcu

于 2025-01-13 15:17:02 首次发布

C语言基础进阶专栏收录该内容

2 篇文章

订阅专栏

C语言进阶系列文章目录

第一章：指针数组及数组指针
 第二章：指针数组指针及数组指针数组

前言

~~不要恨我为什么写这篇文章，因为这个世界就是这么残酷~~

在 C 语言中，除了指针数组和数组指针之外，还有指针数组指针和数组指针数组这两个更复杂但同样重要的概念。它们在声明和使用上都有独特的特点，本文将详细讲解这两个概念的定义、声明、使用方法以及它们之间的区别。

一、指针数组指针

1.1 定义

指针数组是一个数组，其元素都是指针。也就是说，这个数组用来存储指针变量的地址。这些指针可以指向不同类型的变量，但通常是指向同一类型的数据，以便于统一管理和操作。

1.2 声明

指针数组指针的声明格式如下：

类型名 (*指针名)[数组长度];

例如，声明一个指向包含 5 个 int 类型指针的数组的指针：

int *(*ptrArrayPtr)[5];

这里 ptrArrayPtr 是一个指针，它指向一个长度为 5 的 int 类型指针数组。

1.3 使用方法

初始化
可以将一个指针数组的地址赋给指针数组指针。例如：

int a = 1, b = 2, c = 3, d = 4, e = 5;
int *ptrArray[5] = {&a, &b, &c, &d, &e};
int *(*ptrArrayPtr)[5] = &ptrArray;

或者直接赋值指针数组名（指针数组名代表指针数组的首地址）：

ptrArrayPtr = &ptrArray;

访问元素
通过指针数组指针可以访问指针数组中的指针元素，再通过解引用访问其指向的变量。例如：

printf("%d\n", **ptrArrayPtr);  // 输出 a 的值
printf("%d\n", (*ptrArrayPtr)[1]);  // 输出 b 的值
printf("%d\n", (*ptrArrayPtr)[2]);  // 输出 c 的值
printf("%d\n", (*ptrArrayPtr)[3]);  // 输出 d 的值
printf("%d\n", (*ptrArrayPtr)[4]);  // 输出 e 的值

二、数组指针数组

2.1 定义

数组指针数组是一个数组，其元素是数组指针。也就是说，这个数组用来存储数组指针的地址。通过数组指针数组可以访问多个数组。

2.2 声明

数组指针的声明格式如下：

类型名 (*数组名[数组长度])[数组长度];

例如，声明一个包含 3 个指针的数组，每个指针指向一个长度为 4 的 int 类型数组：

int (*arrayPtrArray[3])[4];

这里 arrayPtrArray 是一个包含 3 个元素的数组，每个元素都是一个指向长度为 4 的 int 类型数组的指针。

2.3 使用方法

初始化
可以将一个数组的地址赋给数组指针。例如：

int arr1[4] = {1, 2, 3, 4};
int arr2[4] = {5, 6, 7, 8};
int arr3[4] = {9, 10, 11, 12};
int (*arrayPtrArray[3])[4] = {&arr1, &arr2, &arr3};

或者分别赋值：

arrayPtrArray[0] = &arr1;
arrayPtrArray[1] = &arr2;
arrayPtrArray[2] = &arr3;

访问元素
通过数组指针数组可以访问多个数组中的元素。例如：

printf("%d\n", (*arrayPtrArray[0])[0]);  // 输出 arr1[0] 的值
printf("%d\n", (*arrayPtrArray[0])[1]);  // 输出 arr1[1] 的值
printf("%d\n", (*arrayPtrArray[1])[0]);  // 输出 arr2[0] 的值
printf("%d\n", (*arrayPtrArray[1])[1]);  // 输出 arr2[1] 的值
printf("%d\n", (*arrayPtrArray[2])[0]);  // 输出 arr3[0] 的值
printf("%d\n", (*arrayPtrArray[2])[1]);  // 输出 arr3[1] 的值

三、指针数组指针与数组指针数组的区别

3.1 类型不同

指针数组指针：是一个指针，指向一个指针数组
数组指针数组：是一个数组，其元素是数组指针

3.2 声明方式不同

指针数组指针：类型名后是 (*指针名)[数组长度]，如 int *(*ptrArrayPtr)[5];。
数组指针数组：类型名后是 (*数组名[数组长度])[数组长度]，如 int (*arrayPtrArray[3])[4];。

3.3 使用方式不同

指针数组指针：先解引用指针得到指针数组，再通过下标访问指针数组中的指针元素，再通过解引用访问其指向的变量，如 **ptrArrayPtr或 (*ptrArrayPtr)[i]。
数组指针数组：通过数组指针数组的下标访问数组指针，再通过解引用访问其指向的数组，再通过下标访问数组中的元素，如 (*arrayPtrArray[i])[j]。

3.4 内存布局不同

指针数组指针：指针数组指针本身只占用一个指针大小的空间，它指向的指针数组占用的空间是数组长度乘以指针大小。例如，一个指向包含 5 个int 类型指针的数组的指针，在 64 位系统中，指针数组指针本身占用 8 字节，它指向的指针数组占用 40 字节。
数组指针数组：数组指针数组占用的空间是数组长度乘以指针大小。例如，一个包含 3 个指向长度为 4 的 int 类型数组的指针的数组，在64 位系统中，数组指针数组占用 24 字节。

四、应用场景

4.1 指针数组指针

动态管理指针数组
可以通过指针数组指针动态管理指针数组。例如，动态分配一个指针数组并存储其地址：

int *ptrArray[5];
for (int i = 0; i < 5; i++) {
    ptrArray[i] = (int *)malloc(10 * sizeof(int));  // 分配长度为 10 的 int 类型数组
}
int *(*ptrArrayPtr)[5] = &ptrArray;
// 通过 ptrArrayPtr 访问指针数组中的指针

函数参数传递
指针数组指针可以作为函数参数传递指针数组。例如，定义一个函数处理指针数组：

void processPtrArray(int *(*ptrArrayPtr)[5], int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", *(*ptrArrayPtr + i));
    }
    printf("\n");
}
int a = 1, b = 2, c = 3, d = 4, e = 5;
int *ptrArray[5] = {&a, &b, &c, &d, &e};
int *(*ptrArrayPtr)[5] = &ptrArray;
processPtrArray(ptrArrayPtr, 5);

4.2 数组指针数组

多维数组处理
数组指针数组常用于管理多个多维数组。例如，管理多个二维数组：

int arr1[3][4] = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
};
int arr2[3][4] = {
    {13, 14, 15, 16},
    {17, 18, 19, 20},
    {21, 22, 23, 24}
};
int (*arrayPtrArray[2])[3][4] = {&arr1, &arr2};
// 通过 arrayPtrArray 访问

函数参数传递
数组指针数组可以作为函数参数传递，以便在函数中处理多个数组。以下是一个示例，展示如何将数组指针数组传递到函数中，并在函数中访问和处理这些数组。

//定义一个函数，该函数接受一个数组指针数组作为参数。函数的参数类型是 int (*arrayPtrArray)[3][4]，表示一个指向包含 3 个 int 类型数组的指针数组，每个数组的长度为 4。
void processMultiple2DArrays(int (*arrayPtrArray)[3][4], int numArrays) {
    for (int i = 0; i < numArrays; i++) {
        for (int j = 0; j < 3; j++) {
            for (int k = 0; k < 4; k++) {
                printf("%d ", (*arrayPtrArray[i])[j][k]);
            }
            printf("\n");
        }
        printf("\n");
    }
}
//初始化多个二维数组。然后将这个数组指针数组传递到 processMultiple2DArrays 函数中。
    int arr1[3][4] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };
    int arr2[3][4] = {
        {13, 14, 15, 16},
        {17, 18, 19, 20},
        {21, 22, 23, 24}
    };
    int arr3[3][4] = {
        {25, 26, 27, 28},
        {29, 30, 31, 32},
        {33, 34, 35, 36}
    };

    // 创建数组指针数组
    int (*arrayPtrArray[3])[3][4] = {&arr1, &arr2, &arr3};

五、指针数组指针与数组指针数组的高级应用

5.1 指针数组指针的高级应用

动态二维数组

指针数组指针可以用于创建和管理动态二维数组。例如，创建一个动态二维数组，其中每行的长度可以不同：

int main() {
    int rows = 3;
    int cols[] = {4, 5, 6};  // 每行的列数

    // 创建指针数组指针
    int **ptrArrayPtr = (int **)malloc(rows * sizeof(int *));
    for (int i = 0; i < rows; i++) {
        ptrArrayPtr[i] = (int *)malloc(cols[i] * sizeof(int));
    }

    // 初始化动态二维数组
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols[i]; j++) {
            ptrArrayPtr[i][j] = i * j;
        }
    }
    
    // 访问动态二维数组
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols[i]; j++) {
            printf("%d ", ptrArrayPtr[i][j]);
        }
        printf("\n");
    }

    // 释放内存
    for (int i = 0; i < rows; i++) {
        free(ptrArrayPtr[i]);
    }
    free(ptrArrayPtr);

    return 0;
}

在这个例子中，ptrArrayPtr 是一个指针数组指针，用于管理一个动态二维数组。每行的长度可以不同，通过 malloc 动态分配内存，并在使用完毕后释放内存。

传递多维数组到函数

指针数组指针可以用于传递多维数组到函数中。例如，传递一个动态二维数组到函数中进行处理：

void process2DArray(int **array, int rows, int *cols) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols[i]; j++) {
            printf("%d ", array[i][j]);
        }
        printf("\n");
    }
}

int main() {
    int rows = 3;
    int cols[] = {4, 5, 6};  // 每行的列数

    // 创建指针数组指针
    int **ptrArrayPtr = (int **)malloc(rows * sizeof(int *));
    for (int i = 0; i < rows; i++) {
        ptrArrayPtr[i] = (int *)malloc(cols[i] * sizeof(int));
    }

    // 初始化动态二维数组
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols[i]; j++) {
            ptrArrayPtr[i][j] = i * j;
        }
    }

    // 传递动态二维数组到函数
    process2DArray(ptrArrayPtr, rows, cols);

    // 释放内存
    for (int i = 0; i < rows; i++) {
        free(ptrArrayPtr[i]);
    }
    free(ptrArrayPtr);

    return 0;
}

在这个例子中，process2DArray 函数接受一个指针数组指针 int **array，并处理动态二维数组。

5.2 数组指针数组的高级应用

管理多个多维数组

数组指针数组可以用于管理多个多维数组。例如，管理多个二维数组：

int main() {
    int arr1[3][4] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };
    int arr2[3][4] = {
        {13, 14, 15, 16},
        {17, 18, 19, 20},
        {21, 22, 23, 24}
    };
    int arr3[3][4] = {
        {25, 26, 27, 28},
        {29, 30, 31, 32},
        {33, 34, 35, 36}
    };

    // 创建数组指针数组
    int (*arrayPtrArray[3])[3][4] = {&arr1, &arr2, &arr3};

    // 访问多个二维数组
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            for (int k = 0; k < 4; k++) {
                printf("%d ", (*arrayPtrArray[i])[j][k]);
            }
            printf("\n");
        }
        printf("\n");
    }

    return 0;
}

在这个例子中，arrayPtrArray 是一个数组指针数组，用于管理多个二维数组。通过三层循环，可以访问每个二维数组中的元素。

传递多个多维数组到函数

数组指针数组可以用于传递多个多维数组到函数中。例如，传递多个二维数组到函数中进行处理：

void processMultiple2DArrays(int (*arrays[3])[3][4], int numArrays) {
    for (int i = 0; i < numArrays; i++) {
        for (int j = 0; j < 3; j++) {
            for (int k = 0; k < 4; k++) {
                printf("%d ", (*arrays[i])[j][k]);
            }
            printf("\n");
        }
        printf("\n");
    }
}

int main() {
    int arr1[3][4] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };
    int arr2[3][4] = {
        {13, 14, 15, 16},
        {17, 18, 19, 20},
        {21, 22, 23, 24}
    };
    int arr3[3][4] = {
        {25, 26, 27, 28},
        {29, 30, 31, 32},
        {33, 34, 35, 36}
    };

    // 创建数组指针数组
    int (*arrayPtrArray[3])[3][4] = {&arr1, &arr2, &arr3};

    // 传递多个二维数组到函数
    processMultiple2DArrays(arrayPtrArray, 3);

    return 0;
}

在这个例子中，processMultiple2DArrays 函数接受一个数组指针数组 int (*arrays[3])[3][4]，并处理多个二维数组。

六、总结

指针数组和数组指针在 C 语言中都是非常重要的概念，它们在声明、使用方法和应用场景上都有所不同。指针数组是一个数组，其元素是指针，常用于存储字符串数组和动态管理多个数组。数组指针是一个指针，指向一个数组，常用于处理多维数组和作为函数参数传递多维数组。理解它们的区别和使用方法，可以帮助我们更灵活地使用 C 语言进行编程。