C语言数组与指针的区别详解

C语言数组与指针的区别详解

在C语言中，数组和指针是两个高频使用且容易混淆的概念。尽管数组名在多数表达式中会隐式转换为指向首元素的指针，但这并不意味着数组等同于指针。本文将从本质区别、语法特性和实际应用三个维度，结合《C专家编程》的核心观点，详细解析数组与指针的差异，并通过代码示例验证这些区别。

一、数组和指针的本质区别：存储与类型

1.1 本质定义不同

• 数组是同类型元素的连续集合，在内存中占据一块固定大小的连续空间，其大小由元素类型和数量共同决定（如int a[5]占据5*sizeof(int)字节）。数组名是这块空间的标识符，代表整个数组的起始地址，但本身不是变量。
• 指针是存储地址的变量，其值为另一个变量（或内存单元）的地址。指针本身占据固定大小的内存空间（与系统位数相关，32位系统占4字节，64位系统占8字节），且可以被修改以指向不同的内存单元。

1.2 内存分配方式不同

数组的内存分配在编译期确定（静态数组）或运行时自动分配（局部数组），无需显式申请；而指针需要显式指向已分配的内存（如已定义的变量、动态分配的内存），否则可能成为野指针。

代码示例：内存分配对比

#include <stdio.h>
#include <stdlib.h>

int main() {
    // 数组：编译期确定大小，内存连续分配
    int arr[5] = {1, 2, 3, 4, 5};  // 栈上分配5个int的连续空间
    
    // 指针：存储地址的变量，需显式指向有效内存
    int *ptr;                      // 未初始化的野指针（危险！）
    ptr = arr;                     // 指向数组首元素（合法）
    int *dyn_ptr = malloc(5 * sizeof(int));  // 堆上动态分配内存（需手动释放）
    
    printf("数组元素地址连续性：\n");
    for (int i = 0; i < 5; i++) {
        printf("arr[%d]: %p\n", i, &arr[i]);  // 地址连续递增（每次+4字节，int大小）
    }
    
    free(dyn_ptr);  // 动态分配的内存需手动释放
    return 0;
}

输出结果（地址值为示例，实际取决于系统）：

数组元素地址连续性：
arr[0]: 0x7ffdabcdef10
arr[1]: 0x7ffdabcdef14  // 比前一个地址+4字节
arr[2]: 0x7ffdabcdef18
arr[3]: 0x7ffdabcdef1c
arr[4]: 0x7ffdabcdef20

解释：数组arr的元素地址连续递增，验证了其内存的连续性；而指针ptr本身仅存储一个地址，其指向的内存是否连续取决于被指向的对象（如数组则连续，如分散的变量则不连续）。

二、数组并非指针：语法特性的核心差异

尽管数组名在多数表达式中会转换为指针（即“数组名退化”），但数组名本身不是指针变量，二者在语法特性上存在根本区别。以下从三个关键角度验证这一点。

2.1 sizeof运算符的结果不同

sizeof(数组名)返回整个数组的字节大小，而sizeof(指针)返回指针变量本身的字节大小（与系统位数相关，与指向的对象无关）。

代码示例：sizeof对比

#include <stdio.h>

int main() {
    int arr[5];       // 数组：5个int元素
    int *ptr = arr;   // 指针：指向数组首元素
    
    printf("sizeof(arr) = %zu\n", sizeof(arr));   // 结果：5*4=20（假设int为4字节）
    printf("sizeof(ptr) = %zu\n", sizeof(ptr));   // 结果：8（64位系统）或4（32位系统）
    
    return 0;
}

输出结果（64位系统）：

sizeof(arr) = 20
sizeof(ptr) = 8

解释：sizeof(arr)计算的是整个数组的大小（5个int，共20字节），而sizeof(ptr)仅计算指针变量本身的大小（64位系统中地址占8字节）。这是区分数组和指针的最直接证据。

2.2 数组名不可修改，指针可修改

数组名是常量（const），代表数组的起始地址，不能被赋值或修改；而指针是变量，其值（指向的地址）可以被修改。

代码示例：可修改性对比

#include <stdio.h>

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    int *ptr = arr;
    
    // 数组名不可修改（编译错误）
    // arr = arr + 1;  // 错误：数组名是常量，不能作为左值
    
    // 指针可修改
    ptr = ptr + 1;  // 合法：指针指向arr[1]
    printf("ptr指向的值：%d\n", *ptr);  // 输出：2
    
    return 0;
}

解释：数组名arr是常量，尝试对其赋值（如arr = ...）会触发编译错误；而指针ptr是变量，可以通过ptr++、ptr = &x等操作修改其指向的地址。

2.3 地址类型不同：数组地址 vs 首元素地址

数组名（退化后）的类型是“指向元素类型的指针”（如int *），而数组的地址（&数组名）的类型是“指向数组的指针”（如int (*)[5]）。二者的数值相同，但类型不同，导致指针运算的步长不同。

代码示例：地址类型与指针运算对比

#include <stdio.h>

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    
    // 数组名退化后：指向首元素的指针（int *类型）
    int *elem_ptr = arr;  
    // 数组的地址：指向数组的指针（int (*)[5]类型）
    int (*arr_ptr)[5] = &arr;  
    
    printf("arr = %p\n", (void*)arr);        // 数组首元素地址（如0x7ffdabcdef10）
    printf("&arr = %p\n", (void*)&arr);      // 数组地址（与arr数值相同）
    printf("elem_ptr + 1 = %p\n", (void*)(elem_ptr + 1));  // 步长：+4字节（int大小）
    printf("arr_ptr + 1 = %p\n", (void*)(arr_ptr + 1));    // 步长：+20字节（数组总大小）
    
    return 0;
}

输出结果（地址值为示例）：

arr = 0x7ffdabcdef10
&arr = 0x7ffdabcdef10
elem_ptr + 1 = 0x7ffdabcdef14  // 0x10 + 4 = 0x14
arr_ptr + 1 = 0x7ffdabcdef24   // 0x10 + 20 = 0x24

解释：尽管arr和&arr的数值相同，但类型不同：elem_ptr是int*类型，+1操作移动sizeof(int)字节；arr_ptr是int (*)[5]类型，+1操作移动sizeof(arr)（20字节）。这进一步证明数组名（退化后的指针）与数组地址是不同的概念。

三、数组和指针的其他区别：函数传参、初始化与访问

除上述核心区别外，数组和指针在函数传参、初始化方式和元素访问等场景中也表现出不同特性。

3.1 函数传参时的行为不同

数组作为函数参数时，会退化为指向首元素的指针，函数内部无法通过参数获取数组的原始大小；而指针作为参数时，传递的是指针变量的值（地址），函数内部可通过指针修改指向的内容，但无法修改指针本身（除非传递指针的指针）。

代码示例：函数传参对比

#include <stdio.h>

// 数组作为参数：退化为指针
void array_func(int arr[]) {
    printf("array_func中sizeof(arr) = %zu\n", sizeof(arr));  // 输出8（指针大小）
}

// 指针作为参数：传递地址值
void pointer_func(int *ptr) {
    *ptr = 100;  // 修改指针指向的内容
}

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    int x = 5;
    int *ptr = &x;
    
    array_func(arr);  // 数组退化为指针，函数内无法获取数组大小
    pointer_func(ptr);  // 传递指针，函数内修改指向的内容
    printf("x修改后的值：%d\n", x);  // 输出：100
    
    return 0;
}

输出结果：

array_func中sizeof(arr) = 8
x修改后的值：100

解释：array_func的参数arr[]本质是int*类型，sizeof(arr)得到的是指针大小（8字节），而非数组原始大小（20字节）；pointer_func通过指针参数修改了变量x的值，验证了指针传递的特性。

3.2 初始化方式不同

数组可以通过初始化列表直接赋值，编译器会自动计算元素数量；而指针的初始化必须指向已存在的内存（变量、数组或动态内存），不能直接使用初始化列表。

代码示例：初始化对比

#include <stdio.h>
#include <stdlib.h>

int main() {
    // 数组初始化：直接使用列表，自动确定大小
    int arr[] = {1, 2, 3, 4, 5};  // 大小为5，无需显式指定
    
    // 指针初始化：必须指向有效内存
    int *ptr1 = arr;  // 指向数组首元素（合法）
    int x = 10;
    int *ptr2 = &x;   // 指向变量x（合法）
    int *ptr3 = malloc(5 * sizeof(int));  // 指向动态分配的内存（合法）
    
    // 错误示例：指针不能直接用列表初始化
    // int *ptr4 = {1, 2, 3};  // 编译错误：初始化元素过多
    
    free(ptr3);
    return 0;
}

解释：数组arr通过{1,2,3,4,5}直接初始化，编译器自动确定其大小为5；而指针必须显式指向已分配的内存，直接使用列表初始化（如int *ptr4 = {1,2,3}）会触发编译错误。

3.3 元素访问的底层逻辑不同

数组通过下标访问元素（如arr[i]）的底层逻辑是*(arr + i)，其中arr是数组首地址，i是偏移量；指针访问元素（如ptr[i]）的底层逻辑是*(ptr + i)，其中ptr是指针变量存储的地址。尽管语法相同，但前者的地址是固定的（数组首地址），后者的地址是变量（可修改）。

代码示例：元素访问对比

#include <stdio.h>

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    int *ptr = arr;
    
    // 数组访问：arr[i] = *(arr + i)，arr是固定地址
    printf("arr[2] = %d\n", arr[2]);  // 输出：3
    printf("*(arr + 2) = %d\n", *(arr + 2));  // 输出：3（等价于arr[2]）
    
    // 指针访问：ptr[i] = *(ptr + i)，ptr是变量
    ptr++;  // 指针指向arr[1]
    printf("ptr[2] = %d\n", ptr[2]);  // 输出：4（此时ptr指向arr[1]，ptr[2] = arr[3]）
    printf("*(ptr + 2) = %d\n", *(ptr + 2));  // 输出：4（等价于ptr[2]）
    
    return 0;
}

输出结果：

arr[2] = 3
*(arr + 2) = 3
ptr[2] = 4
*(ptr + 2) = 4

解释：数组访问的地址arr是固定的，arr[2]始终等价于*(arr + 2)；而指针ptr是变量，修改ptr后（如ptr++），ptr[i]的访问结果会随指针指向的变化而变化。

四、总结：数组与指针的核心区别表

为更清晰地对比数组和指针的差异，以下通过表格总结关键特性：

关键结论

数组和指针是C语言中两个独立的概念：数组是数据集合，指针是地址变量。尽管数组名在多数表达式中会退化为指针，但这仅是C语言的语法特性，而非数组本身的属性。理解二者的区别（如sizeof结果、可修改性、地址类型等），是避免数组越界、内存泄漏等常见错误的关键，也是编写高效、正确C代码的基础。