【C语言】数 组与指针：深度剖析与等价表达

💯前言

• 在 C 语言中，数组和指针是两个基础但至关重要的概念。它们之间有着复杂且紧密的关系，理解数组和指针的使用方法、它们如何互相转换，能够帮助程序员写出更加高效和简洁的代码。尤其是当我们在使用数组时，如果能够熟练地运用指针的方式来访问数组元素，不仅能够提升代码的执行效率，还能够加深对 C 语言内存模型的理解。
  本篇文章将详细探讨数组和指针的关系，特别是它们的互换性以及一些常见的等价表达。文章中的分析将基于以下几个方面：数组的定义与特性，指针的作用，数组与指针的互换使用，以及一些常见的数组访问方式。通过这些内容，我们将深入了解 C 语言中数组和指针的妙用。
  C语言
  

💯数组与指针的基本关系

1. 数组的本质：

   在 C 语言中，数组是同类型数据的集合，它在内存中占用一块连续的空间。数组的大小是固定的，并且数组的元素是按顺序存储的。数组的首元素的地址就是数组名，数组名相当于一个指针，指向数组的第一个元素。

   数组的定义：

   int arr[5];
   

   这段代码定义了一个包含5个整数的数组。数组 arr 在内存中占用的是一块连续的空间，数组名 arr 实际上代表了数组首元素的地址。

2. 指针与数组：

   指针是一个存储内存地址的变量。指针本身可以指向任何类型的数据，比如指向整数、字符、结构体等。当我们定义一个指针时，指针变量需要存储一个地址，并且这个地址必须指向相应类型的数据。

   指针的定义：

   int* p;
   p = arr;
   

   这里，指针 p 指向了数组 arr 的首元素。此时，指针 p 和数组 arr 有着密切的关系，它们指向的内存地址是相同的。

💯数组与指针的互换使用

在 C 语言中，数组和指针是可以互换使用的。这是由于数组名代表的是指向数组首元素的指针。事实上，数组名和指针的关系让我们可以使用指针访问数组中的元素。具体来说，数组下标运算符（[]）和指针运算符（*）有着紧密的联系。

数组下标与指针的等价性

通过指针可以访问数组的元素，这是 C 语言中的一个重要特性。实际上，数组下标运算符和指针运算符在本质上是等价的，下面是几种等价的表达方式：

1. arr[i] 和 *(arr + i)

   • arr[i] 是数组下标的常见形式，访问数组中第 i 个元素。
   • *(arr + i) 是通过指针运算的方式访问数组中第 i 个元素。这里，arr 是数组名，表示数组首元素的地址，arr + i 就是数组首元素地址偏移 i 个位置，* 用于解引用得到相应的值。

2. *(arr + i) 和 *(i + arr)

   • 这两个表达式是等价的，因为加法运算是交换律的。arr + i 和 i + arr 都指向数组中第 i 个元素。通过 * 运算符解引用后，它们的结果相同。

3. arr[i] 和 i[arr]

   • 虽然 i[arr] 看起来不太直观，但它与 arr[i] 是完全等价的。C 语言中的数组访问本质上是通过指针加偏移量来完成的，因此 arr[i] 实际上是 *(arr + i)，而 i[arr] 是 *(i + arr)，它们的运算结果是一样的。

💯六个表达式的等价性

在 C 语言中，数组和指针的关系使得某些看起来不同的写法，实际上是完全等价的。以下是六个等价的表达式：

1. arr[i] 和 *(arr + i)

   • arr[i] 是常见的数组下标访问方式，而 *(arr + i) 则是通过指针访问第 i 个元素。两者等价。

2. *(arr + i) 和 *(i + arr)

   • 由于加法的交换律，*(arr + i) 和 *(i + arr) 也是等价的，指向的是同一元素。

3. arr[i] 和 i[arr]

   • arr[i] 和 i[arr] 是等价的表达方式，虽然后者不常见，但在 C 语言中合法且结果相同。

4. *(arr + i) 和 p[i]

   • p[i] 是指针访问数组的常见形式，等同于 *(p + i)，通过偏移量访问数组中的元素。

5. *(arr + i) 和 *(p + i)

   • *(arr + i) 和 *(p + i) 之间的关系类似，都是通过指针加偏移量来访问数组元素。

6. *(i + arr) 和 i[arr]

   • 这两种表达式本质上相同，*(i + arr) 和 i[arr] 指向的是相同的内存位置，因而是等价的。

💯指针运算的注意事项

尽管 i[arr] 是合法的且等价于 arr[i]，但是这种写法通常不推荐使用，因为它不直观，可能让代码的阅读者产生困惑。通常我们更倾向于使用 arr[i] 或 p[i] 这样的常见形式，这样代码更加清晰易懂。

💯数组与指针的转换实例

我们来分析一个简单的程序，演示如何使用指针访问数组。

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdio.h>

int main() {
    int arr[10] = { 0 };  // 定义一个大小为 10 的整数数组
    int* p = arr;       // 定义指针 p，指向数组 arr
    int sz = sizeof(arr) / sizeof(arr[0]); // 计算数组元素个数
    int i = 0;

    // 输入 10 个整数
    for (i = 0; i < sz; i++) {
        scanf("%d", p + i);  // 使用指针来访问数组
    }

    printf("使用arr[i]:");
    // 输出 10 个整数
    for (i = 0; i < sz; i++) {
        printf("%d ", arr[i]);  // 使用指针访问数组并输出
    }
    printf("\n");

    printf("使用*(arr + i):");
    // 输出 10 个整数
    for (i = 0; i < sz; i++) {
        printf("%d ", *(arr + i));  // 使用指针访问数组并输出
    }
    printf("\n");

    printf("使用*(i + arr):");
    // 输出 10 个整数
    for (i = 0; i < sz; i++) {
        printf("%d ", *(i + arr));  // 使用指针访问数组并输出
    }
    printf("\n");

    printf("使用arr[i]:");
    // 输出 10 个整数
    for (i = 0; i < sz; i++) {
        printf("%d ", arr[i]);  // 使用指针访问数组并输出
    }
    printf("\n");

    printf("使用i[p]:");
    // 输出 10 个整数
    for (i = 0; i < sz; i++) {
        printf("%d ", i[p]);  // 使用指针访问数组并输出
    }
    printf("\n");


    printf("使用p[i]:");
    // 输出 10 个整数
    for (i = 0; i < sz; i++) {
        printf("%d ", p[i]);  // 使用指针访问数组并输出
    }
    printf("\n");

    printf("使用*(p + i):");
    // 输出 10 个整数
    for (i = 0; i < sz; i++) {
        printf("%d ", *(p + i));  // 使用指针访问数组并输出
    }


    return 0;
}

分析和解释 C 语言代码：数组与指针的运算

这段代码展示了如何在 C 语言中使用数组和指针的不同方式来访问和输出数组的元素。通过指针运算，可以以多种形式访问和输出数组的内容。让我们逐步分析这段代码。

1. 定义数组和指针

int arr[10] = { 0 };  // 定义一个大小为 10 的整数数组
int* p = arr;         // 定义指针 p，指向数组 arr
int sz = sizeof(arr) / sizeof(arr[0]); // 计算数组元素个数

• arr 是一个大小为 10 的整型数组，初始化为 0。
• p 是一个指针，指向 arr 数组的首元素。
• sz 是数组 arr 的大小，通过 sizeof(arr) / sizeof(arr[0]) 来计算数组的元素个数。这里 sizeof(arr) 获取数组总大小，sizeof(arr[0]) 获取数组单个元素的大小，因此 sz 即为数组中元素的个数。

2. 输入 10 个整数

for (i = 0; i < sz; i++) {
    scanf("%d", p + i);  // 使用指针来访问数组
}

• 使用 scanf 输入 10 个整数，并将它们存入数组 arr 中。这里通过 p + i 来操作数组，因为 p 是指向数组首元素的指针，p + i 相当于指向数组第 i 个元素的指针，scanf 会把输入的整数存入该位置。

3. 使用不同的方式输出数组元素

接下来的代码展示了如何用不同的方式输出数组的元素：

3.1 使用 arr[i] 输出数组元素

printf("使用arr[i]:");
for (i = 0; i < sz; i++) {
    printf("%d ", arr[i]);  // 直接使用数组下标访问数组元素并输出
}

• 通过 arr[i] 直接访问数组元素并输出。这是最常见的访问数组元素的方式。

3.2 使用 *(arr + i) 输出数组元素

printf("使用*(arr + i):");
for (i = 0; i < sz; i++) {
    printf("%d ", *(arr + i));  // 使用指针运算来访问数组元素并输出
}

• *(arr + i) 是通过指针加偏移量来访问数组元素。arr 是数组首元素的地址，arr + i 就是数组第 i 个元素的地址，* 用来解引用，得到该地址存储的值。

3.3 使用 *(i + arr) 输出数组元素

printf("使用*(i + arr):");
for (i = 0; i < sz; i++) {
    printf("%d ", *(i + arr));  // 使用指针运算来访问数组元素并输出
}

• *(i + arr) 和 *(arr + i) 完全等价，它们的运算方式是一样的。这里也展示了指针偏移量的交换性。

3.4 使用 i[p] 输出数组元素

printf("使用i[p]:");
for (i = 0; i < sz; i++) {
    printf("%d ", i[p]);  // 通过指针加偏移量来访问数组元素并输出
}

• i[p] 是合法且等价于 p[i] 的写法。它看起来不太直观，但本质上是通过指针偏移量访问数组元素。实际上，i[p] 是等同于 *(i + p)，和 *(p + i) 相同。

3.5 使用 p[i] 输出数组元素

printf("使用p[i]:");
for (i = 0; i < sz; i++) {
    printf("%d ", p[i]);  // 使用指针访问数组并输出
}

• p[i] 是通过指针访问数组元素的常见方式，等同于 *(p + i)。

3.6 使用 *(p + i) 输出数组元素

printf("使用*(p + i):");
for (i = 0; i < sz; i++) {
    printf("%d ", *(p + i));  // 使用指针运算来访问数组元素并输出
}

• *(p + i) 是通过指针偏移量访问数组元素。p 是指向数组首元素的指针，p + i 就是数组第 i 个元素的指针，* 解引用该指针并输出元素值。

4. 输出示例

假设你输入了以下数据：

1 2 3 4 5 6 7 8 9 10

输出结果将是：

使用arr[i]:1 2 3 4 5 6 7 8 9 10
使用*(arr + i):1 2 3 4 5 6 7 8 9 10
使用*(i + arr):1 2 3 4 5 6 7 8 9 10
使用arr[i]:1 2 3 4 5 6 7 8 9 10
使用i[p]:1 2 3 4 5 6 7 8 9 10
使用p[i]:1 2 3 4 5 6 7 8 9 10
使用*(p + i):1 2 3 4 5 6 7 8 9 10

总结

这段代码展示了数组和指针之间的密切关系。通过不同的指针访问方式，如 arr[i]、*(arr + i)、*(i + arr)、i[p] 和 p[i]，我们可以看到这些方式实际上是等价的，它们都可以用来访问数组中的元素。通过指针的运算，可以非常灵活地操作数组元素。

💯小结

本文详细分析了 C 语言中的数组与指针，特别是它们之间的等价表达方式。我们发现，数组下标运算符和指针运算符在很多情况下是等价的，指针的使用不仅可以访问数组，还能使得程序更加灵活与高效。通过理解数组名、指针和下标之间的关系，程序员可以在编写代码时更加得心应手。

对于数组和指针的相关表达式，尽管它们在语法上可能有不同的形式，但它们在底层的运作原理是相同的。掌握这些等价的表达方式，将有助于你在 C 语言编程中更加灵活地运用数组与指针。

通过本篇文章的讲解，希望读者能够对数组和指针之间的关系有更深刻的理解，并能够在实践中熟练地使用这些技巧，以提高代码的效率和可读性。