在C语言中，指针和数组是两个核心且紧密相关的概念。当它们结合时，就产生了指针数组（Array of Pointers）和数组指针（Pointer to an Array）。这两者在语法、含义和用途上都有明显的区别，理解它们对于深入掌握C语言至关重要。

1. 指针数组 (Array of Pointers)

定义

指针数组，顾名思义，是一个数组，其每个元素都是一个指针。

声明语法

类型 *数组名[数组大小];

例如： int *ptr_array[5];

• ptr_array 是一个数组名。
• [5] 表示这个数组有5个元素。
• int * 表示数组中每个元素的类型都是一个指向 int 型数据的指针。

优先级说明： 由于 []（数组下标运算符）的优先级高于 *（解引用/指针声明运算符），所以 int *ptr_array[5] 被解释为：ptr_array 首先是一个大小为5的数组 (ptr_array[5])，然后这个数组的每个元素是指向 int 的指针 (int *)。

特点与用途

• 存储多个地址：指针数组主要用于存储一组内存地址。
• 管理字符串数组：一个非常常见的用途是管理一组字符串。因为C语言中的字符串通常用字符指针（char*）指向其首字符来表示，所以一个 char* 类型的指针数组可以方便地存储多个字符串的地址。
• 不规则数据结构：可以用来指向不同长度的数组或不同类型的（通过 void*）数据块。

示例：存储字符串

 #include <stdio.h>
 
 int main() {
     // 声明并初始化一个指针数组，每个元素指向一个字符串字面量
     char *names[3] = {
         "Alice",
         "Bob",
         "Charlie"
     };
 
     printf("Names:\n");
     for (int i = 0; i < 3; i++) {
         // names[i] 是一个 char* 指针，指向字符串的开头
         printf("%s\n", names[i]);
     }
 
     // names[0] 指向 "Alice" 的 'A'
     // names[1] 指向 "Bob"   的 'B'
     // names[2] 指向 "Charlie"的 'C'
 
     // 修改指针数组的元素（让它指向另一个字符串）
     names[0] = "David";
     printf("\nAfter modification:\n");
     printf("%s\n", names[0]); // 输出 David
 
     // 注意：这里修改的是指针 names[0] 的指向，
     // 而不是修改字符串 "Alice" 的内容（字符串字面量通常是只读的）。
 
     return 0;
 }

示例：指向不同大小的动态数组

 #include <stdio.h>
 #include <stdlib.h>
 
 int main() {
     int *data_blocks[2]; // 一个包含两个 int* 指针的数组
 
     // 第一个数据块有3个整数
     data_blocks[0] = (int*)malloc(3 * sizeof(int));
     if (data_blocks[0] == NULL) return 1;
     data_blocks[0][0] = 10;
     data_blocks[0][1] = 20;
     data_blocks[0][2] = 30;
 
     // 第二个数据块有5个整数
     data_blocks[1] = (int*)malloc(5 * sizeof(int));
     if (data_blocks[1] == NULL) {
         free(data_blocks[0]);
         return 1;
     }
     for (int i = 0; i < 5; i++) {
         data_blocks[1][i] = (i + 1) * 100;
     }
 
     printf("Data Block 0: ");
     for (int i = 0; i < 3; i++) {
         printf("%d ", data_blocks[0][i]);
     }
     printf("\n");
 
     printf("Data Block 1: ");
     for (int i = 0; i < 5; i++) {
         printf("%d ", data_blocks[1][i]);
     }
     printf("\n");
 
     // 释放内存
     free(data_blocks[0]);
     free(data_blocks[1]);
     data_blocks[0] = NULL;
     data_blocks[1] = NULL;
 
     return 0;
 }

2. 数组指针 (Pointer to an Array)

定义

数组指针，也称为行指针，是一个指针，它指向一个数组。

声明语法

类型 (*指针名)[数组大小];

例如： int (*arr_ptr)[5];

• arr_ptr 是一个指针变量名。
• (*arr_ptr) 中的括号是必需的，它确保 * 首先与 arr_ptr 结合，表明 arr_ptr 是一个指针。
• 这个指针指向一个大小为5的数组 ([5])。
• 该数组的元素类型是 int。

所以，arr_ptr 是一个指向“包含5个 int 型元素的数组”的指针。

特点与用途

• 指向整个数组：数组指针指向的是整个数组的起始地址，而不是数组某个元素的地址（尽管数值上可能相同）。
• 指针运算的步长：对数组指针进行加1运算时，它会向前移动整个数组的大小（即 数组大小 * sizeof(元素类型) 字节）。
• 传递二维数组给函数：数组指针最常见的用途是作为参数传递二维数组（或更高维数组）给函数，因为它可以保持数组的维度信息。

示例：指向一维数组

 #include <stdio.h>
 
 int main() {
     int arr[5] = {1, 2, 3, 4, 5};
 
     // 声明一个数组指针，指向一个包含5个int的数组
     int (*ptr_to_array)[5];
 
     // 将数组 arr 的地址赋给 ptr_to_array
     // &arr 返回整个数组的地址，其类型是 int(*)[5]
     ptr_to_array = &arr;
 
     // 访问数组元素
     // (*ptr_to_array) 解引用得到整个数组 arr
     // 然后可以使用下标访问
     printf("Elements via array pointer:\n");
     for (int i = 0; i < 5; i++) {
         printf("(*ptr_to_array)[%d] = %d\n", i, (*ptr_to_array)[i]);
     }
 
     // 也可以这样访问，因为 ptr_to_array 指向数组的第一个元素（即数组本身）
     // ptr_to_array[0] 相当于 (*ptr_to_array)
     printf("\nAlternative access:\n");
     for (int i = 0; i < 5; i++) {
         printf("ptr_to_array[0][%d] = %d\n", i, ptr_to_array[0][i]);
     }
 
     // 指针运算
     printf("\nAddress of arr: %p\n", (void*)arr);
     printf("Value of ptr_to_array: %p\n", (void*)ptr_to_array);
     printf("Value of ptr_to_array + 1: %p\n", (void*)(ptr_to_array + 1));
     // ptr_to_array + 1 会增加 sizeof(int[5]) = 5 * sizeof(int) 字节
 
     return 0;
 }

示例：作为函数参数处理二维数组

当将二维数组传递给函数时，通常需要指定除第一维之外的所有维度的大小。

 #include <stdio.h>
 
 // 方法1：使用数组指针作为参数
 // matrix 是一个指向包含3个int的数组的指针
 void print_matrix_array_pointer(int (*matrix)[3], int rows) {
     printf("Matrix (using array pointer):\n");
     for (int i = 0; i < rows; i++) {
         for (int j = 0; j < 3; j++) {
             // matrix[i] 相当于 *(matrix + i)，得到第 i 行的数组
             // 然后 matrix[i][j] 访问元素
             printf("%d\t", matrix[i][j]);
         }
         printf("\n");
     }
 }
 
 // 方法2：更常见的二维数组参数形式 (本质上与方法1等价)
 // 编译器会将其视为 int (*matrix)[3]
 void print_matrix_dimensions(int matrix[][3], int rows) {
     printf("Matrix (using dimensions):\n");
     for (int i = 0; i < rows; i++) {
         for (int j = 0; j < 3; j++) {
             printf("%d\t", matrix[i][j]);
         }
         printf("\n");
     }
 }
 
 int main() {
     int my_matrix[2][3] = {
         {1, 2, 3},
         {4, 5, 6}
     };
 
     print_matrix_array_pointer(my_matrix, 2);
     printf("\n");
     print_matrix_dimensions(my_matrix, 2);
 
     return 0;
 }

在
print_matrix_array_pointer 中，matrix 是一个数组指针。matrix + i 会使指针跳过 i 行，指向第 i 行（一个包含3个 int 的数组）的起始位置。

3. 关键区别总结

4. typedef的使用

typedef 可以使复杂的指针声明更易读。

 // 指针数组
 typedef int* IntPtr; // IntPtr 是 int* 的别名
 IntPtr ptr_arr[10];  // ptr_arr 是一个包含10个 int* 的数组
 
 // 数组指针
 typedef int IntArray5[5]; // IntArray5 是一个包含5个int的数组类型
 IntArray5 *ptr_to_arr;  // ptr_to_arr 是一个指向 IntArray5 类型的指针
 
 // 或者更直接地为数组指针类型创建 typedef
 typedef int (*PointerToIntArray5)[5];
 PointerToIntArray5 p_arr5; // p_arr5 是一个指向包含5个int的数组的指针

5. 示例辨析

 int a = 10, b = 20, c = 30;
 
 // 指针数组: arr_p 是一个数组，包含3个 int* 类型的元素
 int *arr_p[3];
 arr_p[0] = &a;
 arr_p[1] = &b;
 arr_p[2] = &c;
 // *arr_p[0] 是 10
 
 int my_arr[3] = {100, 200, 300};
 
 // 数组指针: p_arr 是一个指针，指向一个包含3个 int 元素的数组
 int (*p_arr)[3];
 p_arr = &my_arr;
 // (*p_arr)[0] 是 100

总结

• 指针数组 int *p[N];：p 是一个数组，每个元素都是 int* 指针。
• 数组指针 int (*p)[N];：p 是一个指针，指向一个包含 N 个 int 元素的数组。

理解这两者的区别对于正确使用C语言中的指针和数组至关重要，尤其是在处理字符串集合、多维数组以及向函数传递数组时。注意括号在声明中的使用，它是区分两者的关键。