C语言指针全解析：数组、字符串与二维地址偏移详解

江屿

发布时间：2026-10-16| 6人浏览过

原创

C语言中指针是连接高级语义与底层内存的关键工具，本文重点解析指针与一维数组的地址偏移关联、字符串常量的内存保护机制，以及利用“右左法则”快速辨析指针数组和数组指针的复杂声明语法。

一、指针与一维数组

第1步：理解数组名作为地址常量的性质

在C语言中，数组是内存空间上连续存储的多个同类型变量的集合。要正确使用指针操作数组，必须明确以下三个核心事实：

连续性：数组元素在内存中紧邻排列，这是随机访问和地址计算的物理基础。
入口即首址：数组名（如 a）代表了整个数组的起始内存地址，同时也等于首元素的地址（&a[0]）。数组名是一个地址常量，一旦定义便不可修改（不能执行 a = pb; 这类赋值）。
层级差异：虽然数值相等，但 a 代表一维行数据的首地址，而 &a 代表包含所有元素的二维块的首地址。两者数值相同，但指针步进的单位不同。

我们可以通过以下代码验证这三种地址在数值上的等价性：

#include <stdio.h>
int main()
{
    int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int b = 20;
    char *pb = &b;

    /* a是地址常量，不能被赋值 */
    // a = pb; 

    printf("a = %p, &a[0] = %p, &a = %p\n", a, &a[0], &a);
    printf("&b = %p, pb = %p, pb + 3 = %p\n", &b, pb, pb + 3);
    return 0;
}

第2步：掌握四种等效的数组遍历方式

基于指针与数组的同质性，当指针 p 指向数组 a 时，我们可以使用四种完全等价的方式来访问第 i 个元素：a[i]、*(a + i)、p[i] 和 *(p + i)。其本质都是基于基准地址进行偏移读取。

唯一的区别在于：a 是常量指针，不能改变指向；p 是变量指针，可以重新赋值指向其他内存区域。

#include <stdio.h>
int main()
{
    int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int *p = a, i;

    for (i = 0; i < 10; i++) {
        // 演示四种写法的统一效果
        printf("Index %d: val=%-3d | %-3d | %-3d | %-3d\n", 
               i, a[i], *(a + i), p[i], *(p + i));
    }
    putchar(10);
    return 0;
}

第3步：推导非标准起点的数据修改

指针不仅可以从数组头部开始运算，也可以指向数组中间的任意位置。此时，数组下标会相对于当前指针位置发生偏移变化。

#include <stdio.h>
int main()
{
    int a[10] = {1, 2, 3, 4, 5};
    int *p = &a[1]; // 指针 p 指向第二个元素 a[1]

    p[0] = 20;      // 等价于 a[1] = 20
    p[1] = 30;      // 等价于 a[2] = 30
    p[-1] = 10;     // 等价于 a[0] = 10，反向偏移

    printf("a[0] = %d, a[1] = %d, a[2] = %d\n", a[0], a[1], a[2]);
    return 0;
}

二、指针与字符串的内存保护

C语言中没有专门的字符串类型，通常使用字符数组或字符指针来表示。两者的行为差异源于底层内存分配区域的不同。

第1步：区分栈区与只读数据区

字符数组 a[]：存储在栈区（Stack）。属于局部变量，具备可读可写权限。因此可以通过下标修改内容（如 a[1] = 'z';）。
字符指针 *b：指针变量本身在栈上，但它指向的内容（如字面量 "hello world"）存储在只读数据区（Read-only Data）。对该区域写入会导致程序崩溃（段错误 Segment Fault）。

#include <stdio.h>
int main()
{
    char a[] = "hello world";  // 栈区分配，内容可变
    char *b = "hello world";   // 指向只读文字常量区

    a[1] = 'z';  // 合法，将 "hello" 变为 "hzllo"
    // b[1] = 'z'; // 非法！触发段错误，程序终止

    printf("a = %s\n", a);
    return 0;
}

三、指针和二维数组

第1步：运用“右左法则”区分声明

初学者常混淆“指针数组”与“数组指针”。分辨口诀如下：

看名字右边：如果离标识符最近的是 []，则是数组；如果是 ()（括号内含指针），则优先看左边。
看名字左边：如果前面是 *，则是指针。

char *a[5]：先看到 [5]，是数组。再看左边是指针。结论：**指针数组**（数组里的元素都是指针）。
char (*a)[5]：有括号，先看括号里（指针 *a），再看右边 [5]（是数组）。结论：**数组指针**（指向拥有5个元素的数组的指针）。

第2步：指针数组的实际应用

指针数组主要用于批量处理不同类型的变量，或者构建字符串表。

#include <stdio.h>
int main()
{
    int x = 1, y = 2, z = 3;
    int *p_arr[3]; // 定义一个存放3个整型指针的数组

    p_arr[0] = &x;
    p_arr[1] = &y;
    p_arr[2] = &z;

    *p_arr[0] = 10;
    *p_arr[1] = 20;
    *p_arr[2] = 30;

    printf("x = %d, y = %d, z = %d\n", x, y, z);
    return 0;
}

第3步：解析数组指针的步长逻辑

数组指针本质上是对二维数组行操作的指针。其关键不在于列数，而在于步长（Stride）的定义。当对数组指针执行 +1 操作时，它跨越的距离等于它所指向的那个数组的一行的总字节数。

示例分析：int a[3][3] 是 3行3列的整型矩阵。若定义为 int (*p)[3]，那么 p+1 就是跳过整整一行（12字节）。

#include <stdio.h>
int main(int argc, const char *argv[])
{
	int a[3][3] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
	/*定义数组指针：指向含有3个int元素的数组*/
	int (*p)[3] = a;
	int (*q)[2] = a;

	printf("p = %p, p + 1 = %p\n", p, p+1); // 相差12字节
	*(*(p+1) + 1) = 56; // 修改第二行第二列
	printf("%d\n", a[1][1]);

	printf("q = %p, q + 1 = %p\n", q, q+1); // 相差8字节
	*(*(q+1) + 1) = 56;
	printf("%d\n", a[1][0]); // 注意这里因为步长不同，实际改动的元素不同
	return 0;
}