论指针运算_c语言指针都下标运算-优快云博客

想要了解 C/C++ 中的指针运算，我会从指针运算的本质、核心运算类型（加减、比较、下标）、代码示例和注意事项等方面，用通俗易懂的方式讲解，掌握指针运算的核心逻辑。

一、指针运算的本质

指针的本质是存储内存地址的变量，因此指针运算不是简单的数值加减，而是基于指针指向的类型大小的内存地址偏移运算。

举个核心例子：如果有一个int* p（int占 4 字节），那么p + 1并不是地址值加 1，而是地址值加4 字节（即sizeof(int)），指向内存中的下一个int类型元素；如果是char* p（char占 1 字节），p + 1才是地址值加 1，指向下一个char元素。

简单来说：指针运算的步长 = 指针指向的类型的大小（sizeof(类型)）。

二、指针的核心运算类型

指针支持的运算并不多，主要包括指针加减整数、指针减指针、指针比较、下标运算（本质是指针运算），下面逐一讲解。

1. 指针加减整数（最常用）

格式：指针 ± n（n为整数）作用：指针指向的地址向前 / 向后偏移n * sizeof(指针类型)字节，指向同类型的第n个元素。

代码示例：

cpp

运行

#include <iostream>
using namespace std;

int main() {
    int arr[] = {10, 20, 30, 40};
    int* p = arr; // 指针p指向数组首元素（arr等价于&arr[0]）

    // 输出指针地址和指向的值
    cout << "p的地址：" << (void*)p << "，指向的值：" << *p << endl; // 指向arr[0]，值为10

    // p + 1：偏移sizeof(int)（4字节），指向arr[1]
    p = p + 1;
    cout << "p+1的地址：" << (void*)p << "，指向的值：" << *p << endl; // 指向arr[1]，值为20

    // p - 1：偏移回4字节，指向arr[0]
    p = p - 1;
    cout << "p-1的地址：" << (void*)p << "，指向的值：" << *p << endl; // 指向arr[0]，值为10

    // 直接用指针访问arr[2]（p + 2）
    cout << "*(p+2) = " << *(p + 2) << endl; // 输出30，等价于arr[2]

    return 0;
}

输出说明（以 64 位系统为例，地址仅为示例）：

plaintext

p的地址：0x7ffeefbff460，指向的值：10
p+1的地址：0x7ffeefbff464，指向的值：20
p-1的地址：0x7ffeefbff460，指向的值：10
*(p+2) = 30

可以看到，p+1的地址比原地址大 4 字节（sizeof(int)）。

2. 指针减指针（仅适用于同类型指针）

格式：指针1 - 指针2作用：计算两个指针之间相差的元素个数（不是字节数），要求两个指针必须指向 ** 同一个数组（或连续内存）** 的同类型元素，否则结果未定义。

代码示例：

cpp

运行

#include <iostream>
using namespace std;

int main() {
    int arr[] = {10, 20, 30, 40};
    int* p1 = &arr[0]; // 指向第一个元素
    int* p2 = &arr[3]; // 指向第四个元素

    // 指针减指针：计算元素个数差
    int diff = p2 - p1;
    cout << "p2 - p1 = " << diff << endl; // 输出3（相差3个元素）

    // 注意：指针加指针是不允许的（无意义，编译器报错）
    // int error = p1 + p2; // 编译错误

    return 0;
}

关键注意：

指针减指针的结果是ptrdiff_t类型（一个有符号整数类型，通常等价于long），上面示例中用int接收是因为数值范围匹配。
指针加指针是非法的，编译器会直接报错（两个地址相加没有任何逻辑意义）。

3. 指针的比较运算

格式：指针1 == 指针2、指针1 != 指针2、指针1 < 指针2等作用：比较两个指针的内存地址大小，同样要求指针指向同一个数组（或连续内存），否则比较结果的意义不大。

代码示例：

cpp

运行

#include <iostream>
using namespace std;

int main() {
    int arr[] = {10, 20, 30, 40};
    int* p = arr;
    int* p_end = arr + 4; // 指向数组末尾的下一个位置（arr[4]，超出数组但合法）

    // 用指针比较遍历数组
    while (p < p_end) {
        cout << *p << " ";
        p++; // 指针后移
    }
    cout << endl; // 输出：10 20 30 40

    return 0;
}

说明：

数组末尾的下一个位置（如arr + 4）是 “合法的空指针”，可以用来比较，但不能解引用（*p_end），否则会数组越界。

4. 下标运算（`[]`）：本质是指针运算

C/C++ 中，数组的下标运算arr[i]本质上等价于*(arr + i)，其中arr是数组首地址（指针），i是偏移量。

这意味着：指针可以用下标访问，数组名也可以用指针方式访问。

代码示例：

cpp

运行

#include <iostream>
using namespace std;

int main() {
    int arr[] = {10, 20, 30, 40};
    int* p = arr;

    // 数组的下标运算 = 指针运算
    cout << arr[2] << endl; // 30，等价于*(arr + 2)
    cout << p[2] << endl;   // 30，等价于*(p + 2)
    cout << *(arr + 2) << endl; // 30，和上面一致

    // 甚至可以写“反人类”的写法：i[arr]（不推荐，仅作演示）
    cout << 2[arr] << endl; // 30，因为2[arr]等价于*(2 + arr) = *(arr + 2)

    return 0;
}

关键结论：

数组名是不可修改的指针（常量指针），而指针变量是可以修改的，这是数组名和指针的唯一本质区别（比如arr++是错误的，而p++是合法的）。

三、指针运算的注意事项

类型决定步长：指针运算的偏移量由指针指向的类型决定，不是固定的 1 字节，这是指针运算的核心。
越界风险：指针运算容易导致内存越界（比如p + 10指向不存在的元素），解引用越界指针会导致程序崩溃或数据篡改。
空指针 / 野指针不能运算：NULL（或nullptr）指针、野指针（指向随机地址的指针）不能进行任何运算，否则会触发未定义行为。
仅同类型指针可运算：不同类型的指针（如int*和char*）不能进行减运算或比较，除非强制类型转换（不推荐）。

总结

指针运算的核心是基于类型大小的内存地址偏移，步长为sizeof(指针指向的类型)。
指针支持的运算包括：加减整数（最常用）、减指针（计算元素个数）、比较运算（地址大小）、下标运算（本质是*(指针 + i)）。
数组的下标运算arr[i]等价于*(arr + i)，指针和数组名在运算上几乎可以互换（除了数组名是常量指针）。
使用指针运算时，要严格避免越界和操作空指针 / 野指针。