C语言指针进阶：运算、二级指针与指针数组详解

指针运算与内存位移

指针并非单纯的整数，其加法与减法操作紧密依赖于所指向数据类型的大小。理解这一机制是避免内存访问错误的关键。

第1步：执行指针与整数的加减运算

目的：验证指针移动时实际跨越的内存字节数。

原理：当指针指向 int 类型（假设占4字节）时，p+1 表示地址向高方向移动4个字节，而非1个字节。这对于遍历数组至关重要。

#define VALUE 5
int main()
{
	float values[VALUE];
	float *vp;
	// 使用指针遍历初始化数组
	for (vp = &values[0]; vp < &values[VALUE];)
	{
		*vp++ = 0;// 将当前地址内容置0，随后指针自增
	}
	for (int i = 0; i < VALUE; i++)
	{
		printf("%d ", values[i]);
	}
	return 0;
}

第2步：计算两个指针之间的差值

目的：获取两个指针间包含的元素个数。

操作：只有当两个指针指向同一块连续空间（如数组的不同元素）时，指针A - 指针B 才有意义，结果代表两者之间间隔的数据项数量。

int main()
{
	int arr[10] = { 0 };
	// 方法一：利用下标地址直接相减
	printf("%d\n", &arr[9] - &arr[0]);// 输出9，即中间有9个间隔
	// 方法二：经典长度计算
	printf("%d\n", sizeof(arr)/sizeof(arr[0]));
	
	int* p0 = &arr[0];
	int* p9 = &arr[9];
	printf("%d\n", (p9 - p0));// 同样得到9
	return 0;
}

结合调试器观察，这种位移是非常直观的。例如 &arr[0] 的地址为 0x005cf7f8，则 &arr[0]+1（即下一个 int 元素的地址）会变为 0x005cf7fc，增加了4个十六进制位，印证了 int 类型占用4字节的特性。

注意：指针相减的前提是两个指针必须指向同一数据区域。跨区相减（如 &arr[4] - &ch[3]，其中 arr 和 ch 为不同数组）属于未定义行为。

第3步：使用指针实现字符串求长

目的：利用指针差值替代循环或递归计数。

操作：记录起始地址，移动指针直到遇到字符串结束符 '\0'，最后用尾指针减去首指针即可得出长度。

int mylen(char* pa)
{
	char* p = pa;// 保存起始地址
	while (*pa)// 只要不是' '就继续
	{
		pa++;// 地址后移
	}
	return pa - p;// 返回元素个数
}
int main()
{
	char arr[] = "abcdef";
	int len = mylen(arr);
	printf("%d", len); // 输出6
	return 0;
}

指针关系运算与边界安全

在C语言标准中，指针的比较运算仅限于特定场景。允许指针与指向数组最后一个元素“后面”的一个内存位置的指针进行比较（用于循环终止判断），但绝不允许与指向第一个元素“前面”的地址比较，这会导致未定义行为。

int main()
{
	float values[5] = {1,2,3,4,5};
	float *vp;
	
	// 正向遍历：允许与末尾之后的位置比较
	for (vp = &values[0]; vp < &values[5]; vp++)
	{
		*vp = 0;
	}
	
	// 反向遍历陷阱演示
	// 此写法是不安全的，因为 *--vp 可能导致 vp 指向首元素之前的非法地址
	// for (vp = &values[5]; vp > &values[0]; vp--) *vp = 0; 
	 
	// 安全写法：从最后一个元素开始递减
	for (vp = &values[4]; vp >= &values[0]; vp--) 
	{
		*vp = 0;
	}
	return 0;
}

指针与数组的地址映射

数组名通常等价于数组首元素的地址。这意味着我们可以完全使用指针来代替数组下标进行内存访问，这在优化性能时非常有用。

int main()
{
	int arr[10] = {1,2,3,4,5,6,7,8,9,0};
	int *p = arr; // p 指向 arr[0]
	int sz = sizeof(arr)/sizeof(arr[0]);
	
	// 验证指针偏移与下标的等效性
	for(int i=0; i<sz; i++)
	{
		// 打印 &arr[i] 与 p+i 的地址，两者应完全相同
		printf("&arr[%d] = %p <====> p+%d = %p\n", i, &arr[i], i, p+i);
	}
	return 0;
}

根据上述原理，我们可以通过三种等价方式遍历数组：

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = arr;
	int sz = sizeof(arr) / sizeof(arr[0]);
	
	// 方式1：使用指针偏移量 *(p + i)
	for (int i = 0; i < sz; i++) printf("%d ", *(p + i));
	printf("\n");
	
	// 方式2：使用指针自增 *(p++)
	for (int i = 0; i < sz; i++) printf("%d ", *(p++));
	printf("\n");
	
	// 方式3：传统下标访问 arr[i]
	for (int i = 0; i < sz; i++) printf("%d ", arr[i]);
	printf("\n");
	
	return 0;
}

二级指针的工作原理

既然变量有地址，指针作为变量自然也有自己的地址。用于存放指针地址的变量即为二级指针。它在函数参数传递（修改指针本身）和动态内存管理中极为常见。

int main()
{
	int a = 10;
	int* pa = &a;      // pa 存放 a 的地址（一级指针）
	int** ppa = &pa;   // ppa 存放 pa 的地址（二级指针）
	return 0;
}

通过对 **ppa 的操作可以层层递进：

• *ppa：解引用二级指针，取出的是一级指针 pa 的内容。
• **ppa：再次解引用，取出的是 pa 所指向的值 a。

// 修改 pa 的指向
int b = 20;
*ppa = &b; // 等价于 pa = &b;

// 修改 pa 指向的值
**ppa = 30; // 等价于 *pa = 30; 等价于 a = 30;

指针数组的应用实例

指针数组是指每一个元素都是指针的数组。由于每个元素都只存一个地址，它常被用来模拟二维数组或管理一组异构数据的引用。

第1步：定义指针数组并关联多个一维数组

操作：声明一个包含多个指针的数组，并将其初始化为不同一维数组的首地址。

int main()
{
	int data1[] = { 1,2,3,4,5 };
	int data2[] = { 2,3,4,5,6 };
	int data3[] = { 3,4,5,6,7 };
	
	// arr 是一个指针数组，每个元素存放一个 int* 地址
	int* arr[3] = { data1, data2, data3 };
	
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 5; j++)
		{
			// arr[i][j] 自动完成两次解引用：先取地址，再取值
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
	return 0;
}

在此结构中：
arr[0] 指向 data1 的首地址；
arr[0][0]*(arr[0] + 0)，最终取出数值 1。

第2步：显式解引用操作

说明：如果不习惯使用 arr[i][j] 语法，也可以手动完成两次指针解引用。

	// 等价写法
	printf("%d ", *(arr[i] + j));

第3步：管理分散的独立变量地址

目的：展示指针数组不一定要关联完整的数组，也可以仅存变量的地址。

int main()
{
	int a = 10, b = 11, c = 12, d = 13, e = 14;
	// 指针数组存放的是普通变量的地址
	int* arr[5] = { &a, &b, &c, &d, &e };
	
	for (int i = 0; i < 5; i++)
	{
		// 必须先解引用 arr[i] 拿到 a,b,c...的地址，再解引用取值
		printf("%d ", *(arr[i]));
	}
	return 0;
}

总结

本文系统梳理了C语言指针的进阶体系。从基础的指针加减及其对应的内存字节移动，到必须严格遵守的相对位置关系运算；再到管理指针自身的二级指针机制，最后是具备强大扩展能力的指针数组。这些概念构成了C语言处理复杂数据结构的基石。

以上就是C语言指针进阶运算、二级指针与指针数组应用的详细内容，更多关于C语言指针的资料请关注本站其它相关文章！