在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. 关键区别总结
特性 | 指针数组 (type *name[size]) | 数组指针 (type (*name)[size]) |
本质 | 数组 | 指针 |
元素类型 | 指针 (type *) | 指向一个数组 (type[size]) |
存储内容 | 存储多个地址 | 存储一个数组的地址 |
sizeof(name) | size * sizeof(type *) (整个数组的大小) | sizeof(pointer) (指针本身的大小) |
name+1 | 指向数组的下一个元素 (即下一个指针) | 指向下一个同样大小的数组 (地址增加 size * sizeof(type)) |
主要用途 | 管理字符串数组、指向不同数据块的集合 | 处理多维数组、作为函数参数传递数组 |
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语言中的指针和数组至关重要，尤其是在处理字符串集合、多维数组以及向函数传递数组时。注意括号在声明中的使用，它是区分两者的关键。