32 C 语言指针的长度与运算（指针加减整数、指针自增自减、同类型指针相减、指针的比较运算）

目录

1 指针的长度

2 指针与整数的加减运算

3 指针自增与自减

4 同类型指针相减

5 指针的比较运算

6 测试题 

---

1 指针的长度

        在 C 语言中，sizeof 运算符可以用来计算指针的长度。指针的长度实际上与指针所指向的数据类型无关，而是与系统的位数（即系统架构）有关。具体来说：

• 32 位系统：无论指针指向什么类型的数据（如 int、char、float 等），指针的长度都是 4 个字节（32 位）。
• 64 位系统：无论指针指向什么类型的数据，指针的长度都是 8 个字节（64 位）。

        下面是一个示例，展示了如何使用 sizeof 运算符来计算不同类型指针的长度：

#include <stdio.h>

int main()
{
    int *int_ptr;
    char *char_ptr;
    float *float_ptr;
    double *double_ptr;

    printf("int 指针的长度: %zu 字节\n", sizeof(int_ptr));
    printf("char 指针的长度: %zu 字节\n", sizeof(char_ptr));
    printf("float 指针的长度: %zu 字节\n", sizeof(float_ptr));
    printf("double 指针的长度: %zu 字节\n", sizeof(double_ptr));

    return 0;
}

        在 32 位系统上运行上述代码，输出可能是：

int 指针的长度: 4 字节
char 指针的长度: 4 字节
float 指针的长度: 4 字节
double 指针的长度: 4 字节

        在 64 位系统上运行上述代码，输出可能是：

int 指针的长度: 8 字节
char 指针的长度: 8 字节
float 指针的长度: 8 字节
double 指针的长度: 8 字节

结论：

• 指针的长度与系统架构有关：在 32 位系统中，所有指针的长度都是 4 个字节；在 64 位系统中，所有指针的长度都是 8 个字节。
• 指针的长度与指向的数据类型无关：无论指针指向 int、char、float 还是 double，指针本身的长度是固定的，由系统的位数决定。

---

2 指针与整数的加减运算

        指针与整数的加减运算表示指针所指向的内存地址的移动。具体来说：

• 加法运算：指针加一个整数表示指针向后移动。
• 减法运算：指针减一个整数表示指针向前移动。

        指针移动的步长与指针指向的数据类型有关。每移动一个单位，指针会移动相应数据类型所占的字节数。例如：

• 如果指针指向 int 类型的数据，int 通常占用 4 个字节，那么指针加 1 会向后移动 4 个字节，指针减 2 会向前移动 8 个字节。
• 如果指针指向 char 类型的数据，char 通常占用 1 个字节，那么指针加 1 会向后移动 1 个字节，指针减 2 会向前移动 2 个字节。

        数组的元素在内存中是连续存储的，因此通过数组元素可以很好地演示指针加减整数的情况。以下是一个示例：

#include <stdio.h>

int main()
{
    // 创建一个包含 5 个整数的数组
    int nums[] = {10, 20, 30, 40, 50};

    // 创建一个指针并将其初始化为数组第一个元素的地址
    int *ptr = &nums[0];
    // int *ptr = nums; 或者直接指向数组名 和上面等价

    // 打印指针的地址和指针所指向的值
    printf("初始状态: ptr=%p, *ptr=%d \n", (void *)ptr, *ptr);

    // 指针加 3，指针指向 int 类型，每个 int 占 4 个字节
    // 因此，指针会向后移动 3 * 4 = 12 个字节
    ptr += 3;
    printf("指针加 3 后: ptr=%p, *ptr=%d \n", (void *)ptr, *ptr);

    // 指针减 2，指针会向前移动 2 * 4 = 8 个字节
    ptr -= 2;
    printf("指针减 2 后: ptr=%p, *ptr=%d \n", (void *)ptr, *ptr);

    return 0;
}

        输出结果如下所示：

---

3 指针自增与自减

        指针的自增和自减本质上是通过加减整数来实现的。自增会使指针向后移动，自减会使指针向前移动。移动的步长与指针指向的数据类型有关。每移动一个单位，指针会移动相应数据类型所占的字节数。例如，如果指针指向 short 类型的数据，short 通常占用 2 个字节，那么指针自增 1 会向后移动 2 个字节，指针自减 1 会向前移动 2 个字节。

#include <stdio.h>

int main()
{
    // 创建数组，元素都是 short 类型，每个元素占据 2 个字节
    short nums[] = {10, 20, 30, 40, 50};

    // 定义常量记录数组长度
    const int len = sizeof(nums) / sizeof(nums[0]); // 5

    // 利用指针自增遍历数组元素
    // 创建指针并指向数组第一个元素的地址
    short *ptr = &nums[0];
    // short *ptr = nums; 或者直接指向数组名 和上面等价

    // 循环遍历数组
    for (int i = 0; i < len; i++)
    {
        // 打印当前元素的索引、地址和值
        printf("元素索引：%d, 元素地址：%p, 元素值：%hd \n", i, (void *)ptr, *ptr);
        // 指针自增，向后移动一个 short 类型的单位（2个字节）
        ptr++;
    }
    printf("\n");

    // 循环遍历数组，从最后一个元素到第一个元素
    // 此时指针超出数组界限，需先自减一次
    for (int i = len - 1; i >= 0; i--)
    {
        // 指针自减，向前移动一个 short 类型的单位（2个字节）
        ptr--;
        // 打印当前元素的索引、地址和值
        printf("元素索引：%d, 元素地址：%p, 元素值：%hd \n", i, (void *)ptr, *ptr);
    }

    return 0;
}

        输出结果如下所示：

        在上述示例中，当第一次循环（正序输出数组元素）结束后，指针 ptr 已经超出了数组的边界，指向了数组最后一个元素之后的位置，如下图所示。因此，在进行第二次循环（倒序输出数组元素）之前，需要先将指针重置为数组最后一个元素的地址，以确保能够正常输出。

        可以使用 ptr-- 重置指针：在第一次循环结束后，指针 ptr 超出了数组的边界。可以通过 ptr-- 将指针向前移动一个单位，使其指向数组的最后一个元素。如上述代码中的第二次循环一开始就 使用 ptr-- 重置指针。

        也可以直接重置指针：可以直接将指针 ptr 重新初始化为数组最后一个元素的地址，这样可以确保指针指向正确的起始位置。如下代码所示：

#include <stdio.h>

int main()
{
    // 创建一个包含 5 个 short 类型的数组
    short nums[] = {10, 20, 30, 40, 50};
    int n = sizeof(nums) / sizeof(nums[0]); // 计算数组的长度

    // 创建指针并初始化为数组第一个元素的地址
    short *ptr = &nums[0];

    // 正序输出数组元素
    printf("正序输出数组元素:\n");
    for (int i = 0; i < n; i++)
    {
        printf("元素索引：%d, 元素地址：%p, 元素值：%hd \n", i, (void *)ptr, *ptr);
        ptr++; // 指针自增，向后移动一个 short 类型的单位（2个字节）
    }
    printf("\n");

    // 重置指针，使其指向数组最后一个元素的地址
    ptr = &nums[n - 1];

    // 倒序输出数组元素
    printf("倒序输出数组元素:\n");
    for (int i = n - 1; i >= 0; i--)
    {
        printf("元素索引：%d, 元素地址：%p, 元素值：%hd \n", i, (void *)ptr, *ptr);
        ptr--; // 指针自减，向前移动一个 short 类型的单位（2个字节）
    }

    return 0;
}

---

4 同类型指针相减

        相同类型的指针可以进行减法运算，返回它们之间的距离，即相隔多少个数据单位。高位地址减去低位地址，返回的是正值；低位地址减去高位地址，返回的是负值。同类型指针相减的结果是一个 ptrdiff_t 类型的数据，ptrdiff_t 是一个带符号的整数，格式输出中对应的格式占位符是 %td。

        以下是一个示例，演示了如何使用同类型指针相减来计算它们之间的距离：

#include <stdio.h>

int main()
{
    // 创建一个包含 5 个整数的数组
    int nums[] = {10, 20, 30, 40, 50};

    // 创建指针并指向数组第一个元素的地址
    int *ptr1 = &nums[0];
    // 创建指针并指向数组第四个元素的地址
    int *ptr2 = &nums[3];

    // 打印查看原始内容
    printf("ptr1地址：%p\n", ptr1);
    printf("ptr2地址：%p\n", ptr2);

    // 计算两个指针之间的距离
    // ptr2 - ptr1 应该等于 3，因为 ptr2 指向第四个元素，ptr1 指向第一个元素
    printf("ptr2 - ptr1 = %td \n", ptr2 - ptr1); // 输出 3
    // ptr1 - ptr2 应该等于 -3，因为 ptr1 指向第一个元素，ptr2 指向第四个元素
    printf("ptr1 - ptr2 = %td \n", ptr1 - ptr2); // 输出 -3

    // 再连续创建两个变量
    double d1 = 1.0;
    double d2 = 2.0;

    // 创建指针并分别指向 d1 和 d2 的地址
    double *p1 = &d1;
    double *p2 = &d2;

    printf("p1地址：%p\n", p1);
    printf("p2地址：%p\n", p2);

    // 计算两个指针之间的距离
    // p1 - p2 应该等于 1，因为 p1 指向 d1，p2 指向 d2，d1 和 d2 在内存中是相邻的
    printf("p1 - p2 = %td \n", p1 - p2); // 输出 1
    // p2 - p1 应该等于 -1，因为 p2 指向 d2，p1 指向 d1，d1 和 d2 在内存中是相邻的
    printf("p2 - p1 = %td \n", p2 - p1); // 输出 -1

    return 0;
}

        输出结果如下所示：

---

5 指针的比较运算

        指针之间可以进行比较运算，如 ==、!=、<、<=、>、>=。这些运算符比较的是指针所指向的内存地址的大小，返回值是 int 类型的整数，1 表示 true，0 表示 false。

        以下是一个示例，演示了如何使用指针的比较运算：

#include <stdio.h>

int main()
{
    // 创建一个包含 5 个整数的数组
    int nums[] = {10, 20, 30, 40, 50};
    double n = 1.0;

    // 创建指针并指向数组第一个元素的地址
    int *ptr1 = &nums[0];
    // 创建指针并指向数组第四个元素的地址
    int *ptr2 = &nums[3];
    // 创建指针也指向数组第一个元素的地址
    int *ptr3 = &nums[0];
    // 创建指针指向变量 n 的地址
    double *ptr4 = &n;

    // 输出指针指向的地址
    printf("ptr1=%p\n", (void *)ptr1);
    printf("ptr2=%p\n", (void *)ptr2);
    printf("ptr3=%p\n", (void *)ptr3);
    printf("ptr4=%p\n\n", (void *)ptr4);

    // 进行比较
    // 比较 ptr1 和 ptr2 的地址
    printf("ptr1 > ptr2: %d \n", ptr1 > ptr2); // 比较 ptr1 是否大于 ptr2
    printf("ptr1 < ptr2: %d \n", ptr1 < ptr2); // 比较 ptr1 是否小于 ptr2
    // 比较 ptr1 和 ptr3 的地址
    printf("ptr1 == ptr3: %d \n", ptr1 == ptr3); // 比较 ptr1 是否等于 ptr3

    // 比较不同类型的指针（ptr4 和 ptr1）
    // 注意：不同类型的指针进行比较会引发编译器警告
    printf("ptr4 > ptr1: %d \n", ptr4 > ptr1); // 比较 ptr4 是否大于 ptr1

    return 0;
}

        注意，不同类型的指针进行比较会引发编译器警告。如下所示：

        输出结果如下所示：

---

6 测试题 

1. 请写出下面程序的运行结果（64 位操作系统）。

int num = 250;
int *p = #
printf("%zu \n", sizeof p);
printf("%zu \n", sizeof *p);

【答案】

        8

        4

【解析】

        sizeof p 是计算指针本身的长度，指针存储的是地址，在 64 位操作系统下，地址占 8 个字节。

        sizeof *p 是计算指针指向的数据的长度，指针 p 指向 int 类型变量 num，int 类型长度是 4 个字节。

---

2. 请写出下面程序的运行结果。

int arr[] = {10,20,30,40,50};
int *p = arr;  
printf("%d", *(p+1) + *(p+2)); 

【答案】

        50

【解析】

        指针 p 指向数组 arr 的首元素地址

        p+1 得到数组 arr 第二个元素的地址，*(p+1) 得到第二个元素的值 20。

        p+2 得到数组 arr 第三个元素的地址，*(p+2) 得到第三个元素的值 30。