C语言数组与指针详解：内存布局、sizeof差异与实战应用

在C语言的学习过程中，数组和指针一直是核心且易混淆的知识点。许多初学者看到以下两行代码时，会误以为它们是等价的：

char s1[] = "liangxu";
char *s2 = "liangxu";

尽管它们都能存储字符串"liangxu"，但背后的机制截然不同。不理解其本质区别，在实际开发中极易引发难以调试的Bug。本文将通过这两行代码，深入剖析数组与指针的核心差异。

1. 从内存布局看本质区别

理解数组和指针，必须从内存布局这一根本点切入。

1.1 数组的内存布局

声明 char s1[] = "liangxu"; 时，编译器执行以下操作：

1. 计算字符串 "liangxu" 的长度（包含结尾的 \0），共8字节。
2. 在栈上分配一块连续的8字节内存。
3. 将字符串内容复制到这块内存中。

s1 代表这块连续内存的首地址，其本身是一个地址常量，不能被重新赋值（如 s1 = “hello”; 会编译失败）。以下程序验证其内存连续性：

#include <stdio.h>
int main(void){
    char s1[] = "liangxu";
    printf("s1数组的地址: %p\n", (void*)s1);
    printf("s1数组的大小: %zu字节\n", sizeof(s1));
    // 打印每个字符的地址
    for (int i = 0; i < sizeof(s1); i++){
        printf("s1[%d] = '%c', 地址: %p\n", i, s1[i], (void*)&s1[i]);
    }
    return 0;
}

运行结果显示，所有字符的地址是连续的。

1.2 指针的内存布局

对于 char *s2 = "liangxu";，过程完全不同：

1. 字符串字面量 "liangxu" 被存储在程序的只读数据段（常量区）。
2. 在栈上分配一个指针变量 s2（32位系统4字节，64位系统8字节）。
3. s2 的值被初始化为该字符串在只读数据段的首地址。

s2 是一个变量，存储着一个地址值。验证代码如下：

#include <stdio.h>
int main(void){
    char *s2 = "liangxu";
    printf("s2指针变量的地址: %p\n", (void*)&s2); // s2本身的地址
    printf("s2指针变量的大小: %zu字节\n", sizeof(s2));
    printf("s2指向的字符串地址: %p\n", (void*)s2); // s2存储的地址
    return 0;
}

s2 本身的地址和它指向的字符串地址位于不同的内存区域。

2. 可修改性的关键差异

这是实际开发中最易导致程序崩溃的区别点。

2.1 数组内容可修改

由于数组内容位于栈上（可读写），我们可以安全地修改它：

#include <stdio.h>
#include <string.h>
int main(void){
    char s1[] = "liangxu";
    s1[0] = 'L'; // 允许：修改单个字符
    strcpy(s1, "LIANGXU"); // 允许：修改整个字符串
    printf("%s\n", s1);
    return 0;
}

2.2 指针指向的字符串不可修改

指针 s2 指向只读数据段，修改其内容会导致运行时错误（段错误）：

#include <stdio.h>
int main(void){
    char *s2 = "liangxu";
    // s2[0] = 'L'; // 危险！运行时崩溃（Segmentation fault）
    s2 = "hello"; // 允许：s2本身是变量，可指向新地址
    printf("%s\n", s2);
    return 0;
}

3. sizeof运算符的截然不同

sizeof 运算符在数组和指针上的表现是另一个经典考点，深刻理解这一点对于掌握算法与数据结构中的内存计算至关重要。

#include <stdio.h>
#include <string.h>
int main(void){
    char s1[] = "liangxu";
    char *s2 = "liangxu";

    printf("sizeof(s1) = %zu\n", sizeof(s1)); // 输出 8 (包含'\0')
    printf("sizeof(s2) = %zu\n", sizeof(s2)); // 输出 4或8 (指针本身大小)
    printf("strlen(s1) = %zu\n", strlen(s1)); // 输出 7
    printf("strlen(s2) = %zu\n", strlen(s2)); // 输出 7
    return 0;
}

核心区别：对数组名使用 sizeof 得到整个数组的字节大小；对指针使用 sizeof 得到指针变量本身的字节大小。

这个区别在函数传参时尤为重要，因为数组作为参数会退化为指针：

#include <stdio.h>
void print_size(char str[]){ // 形参`str`实为指针
    printf("函数内sizeof(str) = %zu\n", sizeof(str)); // 输出指针大小
}
int main(void){
    char s1[] = "liangxu";
    printf("main中sizeof(s1) = %zu\n", sizeof(s1)); // 输出数组大小
    print_size(s1);
    return 0;
}

4. 函数参数行为解析

虽然在函数参数中数组会退化为指针，但明确其差异有助于编写更清晰的代码。

#include <stdio.h>
#include <string.h>
// 方式1：数组表示法（实际是指针）
void modify_string1(char str[]){
    strcpy(str, "hello");
}
// 方式2：明确使用指针
void modify_string2(char *str){
    strcpy(str, "world");
}
// 注意：要修改指针变量本身，需传递指针的地址
void modify_pointer_correct(char **str){
    *str = "new string";
}

int main(void){
    char buffer[20] = "liangxu";
    char *p = NULL;

    modify_string1(buffer); // 正确：修改buffer内容
    printf("%s\n", buffer); // 输出 hello

    modify_pointer_correct(&p); // 正确：修改p的指向
    printf("%s\n", p); // 输出 new string
    return 0;
}

5. 多维数组与指针数组对比

扩展到多维情况，区别更为显著。

#include <stdio.h>
int main(void){
    // 二维数组：连续的内存块
    char arr1[][8] = {"liangxu", "hello", "world"};
    // 指针数组：每个元素是一个独立的指针
    char *arr2[] = {"liangxu", "hello", "world"};

    printf("sizeof(arr1): %zu\n", sizeof(arr1)); // 3*8=24字节
    printf("sizeof(arr2): %zu\n", sizeof(arr2)); // 3*指针大小

    arr1[0][0] = 'L'; // 允许：修改栈上数据
    // arr2[0][0] = 'L'; // 禁止：修改只读数据段

    arr2[0] = "LIANGXU"; // 允许：改变指针指向
    return 0;
}

6. 实际应用最佳实践

理解差异后，如何正确选择？

6.1 何时使用数组？

• 需要修改内容时：如栈上的字符串缓冲区。
• 固定大小的缓冲区：如临时数据存储。
• 数据生命周期与作用域严格绑定时。

void process_data(void){
    char buffer[64]; // 栈上分配，自动回收
    sprintf(buffer, "Value: %d", read_sensor());
    uart_send(buffer);
}

6.2 何时使用指针？

• 只读的字符串常量：如错误信息、配置键名。
• 需要灵活指向不同数据时。
• 传递大型结构避免拷贝开销时。

const char* get_status_msg(int code){
    switch(code){
        case 0: return "Success";
        case 1: return "Busy";
        default: return "Unknown";
    }
}

7. 总结

通过对比 char s1[] 与 char *s2，我们厘清了数组与指针的五大核心区别：

1. 内存分配：数组在栈/静态区分配连续空间并复制数据；指针变量存储一个指向（可能为只读区）数据的地址。
2. 可修改性：数组内容可修改；指针指向的常量字符串不可修改，但指针本身可重定向。
3. sizeof结果：对数组取大小得到数据总长；对指针取大小得到指针变量本身的长度。
4. 函数参数：数组作为参数传递时会退化为指向其首元素的指针，丢失长度信息。
5. 赋值操作：数组名是常量，不可被赋值；指针是变量，可以被重新赋值。

在资源受限的嵌入式系统等场景中，深刻理解这些底层差异是编写高效、健壮C语言代码的基石。正确选择数组或指针，能够有效避免内存访问错误、提升程序性能并降低网络与系统层面的调试复杂度。