C 指针

是什么，为什么存在

指针（pointer）是一种标量类型，它的值可以表示一个地址。 对象指针（object pointer） 是目标为 void 或对象类型的指针，与函数指针相区别；int *balance 可以保存 int 对象的地址。指针变量本身也是对象，复制它只会复制地址，不会复制所指对象。

一元 & 从左值取得地址，一元 * 解引用指针并产生所指对象的左值。若 balance 是可用的 int *，*balance = 500 会写入目标 int，不是改变 balance 中保存的地址。声明中的 * 与表达式中的 * 写法相同，角色却不同。

指针让函数间接访问调用方对象，也让代码表示数组区间、动态对象、链式数据结构和硬件映射。C 按值传递所有实参；把指针交给函数时，函数得到的是地址副本，却仍可通过该副本访问同一个目标对象。这是 C 模拟输出参数与借用接口的基础。

一个指针值不携带数组长度、所有权或剩余生命周期。int * 既可能指向单个 int，也可能指向数组中的元素，还可能为空或已经失效。正确性来自声明之外的接口契约，因此代码审查必须把地址、范围和生命周期放在一起看。

函数指针也保存地址，但它们遵守另一组转换与调用规则。本主题聚焦对象指针；回调签名和间接调用属于 cpp/c-function-pointers，动态分配与释放属于 cpp/c-memory，数组类型与数组到指针转换的完整规则属于 cpp/c-arrays。

工作原理

下面的关系描述了最基本的往返。&count 生成指向 count 的指针值，*cursor 再产生表示同一个对象的左值。图中没有长度或所有权边，因为裸指针不保存这两项信息。

声明、地址与解引用

声明应从名称向外读。int *cursor 声明一个指向 int 的指针；int **slot 声明一个指向 int * 对象的指针；int (*row)[4] 则声明一个指向四元素 int 数组的指针。括号会改变结合方式，不能当作装饰省略。

指针类型决定解引用所得左值的类型。编译器会按目标类型检查读取、写入和算术，但不会证明地址仍对应一个活着且对齐的该类型对象。强制转换可以改变编译器看到的类型，不能让不满足条件的地址变得有效。

空指针（null pointer） 明确表示没有目标。NULL 是实现提供的空指针常量宏；在指针上下文中，整数常量 0 也可转换为空指针。空指针可以复制和比较，却不能解引用。

数组范围与指针运算

数组表达式在多数取值上下文中发生 数组到指针转换（array-to-pointer conversion） ，结果指向首元素。转换只提供首元素地址，不附带元素数。函数形参中的 int values[8] 也会调整为 int *values，其中的 8 不形成运行时边界检查。

若 cursor 指向数组元素，cursor + 1 会前进一个目标元素，而不是一个字节。cursor[index] 定义为 *(cursor + index)。只有当结果仍指向同一数组的元素或恰好指向尾后位置时，这种加减才符合数组遍历规则。

尾后指针可以比较、相减或充当半开区间的结束标记，但不能解引用。两个元素指针只有在属于同一数组对象或其尾后位置时，才能可靠地相减或做顺序比较。数值上相邻的两个独立对象不会因此组成一个数组。

空指针、有效性与生命周期

空值检查只排除一种无效情况。一个非空指针仍可能未初始化、已经悬空、越过边界、没有满足对齐，或者以不允许的类型访问存储。解引用前必须由程序逻辑分别证明这些条件。

对象生命周期结束后，保存其地址的别名不会自动清空。这样的别名是 悬空指针（dangling pointer） ，不得继续读取目标、写入目标或交给要求有效对象的 API。把某一个变量设为 NULL 只能保护那一个变量，无法修复其他副本。

局部自动对象通常在所属块退出时结束生命周期。返回其地址会立刻留下悬空结果。静态存储期对象、调用方提供的对象和动态分配对象有不同的结束条件；接口需要明确借用能持续到何时。

const 限定放在哪里

const 可以限定目标，也可以限定指针对象本身。读声明时先找变量名，再看 * 两侧：const int *view 允许改变 view 的地址，但不能经它修改目标；int *const fixed 可以修改目标，却不能给 fixed 重新赋地址。

把 int * 交给接收 const int * 的只读接口通常是安全的限定增加。反方向转换会丢弃限定；即使强制转换让代码通过编译，修改一个实际定义为 const 的对象仍产生 未定义行为（undefined behavior） 。const 还是浅层约束，不会递归冻结结构体指针成员所指的其他对象。

参数仍按值传递

函数取得指针实参的副本。给形参重新赋值只改变这个副本，调用方的指针变量不变；经形参解引用则能改变双方共同指向的对象。区分「改目标」与「改调用方保存的地址」可以避免多加或少加一层 *。

如果函数需要更新调用方的 int *，可以接收 int **，让实参使用 &pointer。这仍然是按值传递：被复制的是 int ** 地址，而函数通过它找到并修改调用方的 int * 对象。输出形参还应说明失败时是否保持原值。

void * 可以承载对象地址而暂时擦除具体目标类型。对象指针可转换为 void * 并再转换回原类型，但调用方和被调用方必须对原始类型、对齐、长度与生命周期达成一致。void * 本身不能解引用，也不是动态类型检查机制。

示例

下面四个程序依次展示单对象借用、半开数组区间、只读查找结果和二级指针输出。每个文件都用本地 GCC 13.3.0 按 -std=c2x -Wall -Wextra -Wconversion -Wpedantic -Werror 编译，再运行得到所示输出。

通过借用修改一个对象

debit 接收 int * 的副本。它不会拥有或释放账户对象，但在非空时可通过解引用修改调用方的 balance。

&balance 的类型是 int *，与形参匹配。balance 的生命周期覆盖整个调用，因此函数执行期间借用有效。函数返回后，原对象仍由 main 管理。

检查 NULL 只是函数契约的一部分。调用方仍必须传入一个活着且可写的 int 对象地址；debit 无法从地址数值自行验证这件事。

遍历半开指针区间

count_at_least 接收同一数组中的起始和尾后指针。循环只解引用 [first, last) 内的元素，结束指针本身从不解引用。

#include <stdio.h>

static int count_at_least(const int *first,
                          const int *last,
                          int floor) {
    int count = 0;
    for (const int *cursor = first; cursor != last; ++cursor) {
        if (*cursor >= floor) {
            ++count;
        }
    }
    return count;
}

int main(void) {
    const int readings[] = {18, 21, 17, 24, 21};
    const int *end = readings + 5;

    printf("matches: %d\n", count_at_least(readings, end, 21));
    printf("empty: %d\n", count_at_least(end, end, 21));
    return 0;
}

matches: 3
empty: 0

readings + 5 可以形成结束标记，因为它恰好是尾后位置。把 last 换成另一个数组的地址会破坏接口前置条件；这个循环没有办法仅凭两个地址检测这种错误。

参数使用 const int *，表示函数只观察元素。局部变量 cursor 自身仍可递增，因为 const 限定的是目标 int，不是指针对象。

返回数组中的只读位置

查找函数返回首个偶数元素的地址，没有匹配时返回空指针。调用方只有在空值检查后才解引用，并且只在原数组仍存活时保存结果。

#include <stddef.h>
#include <stdio.h>

static const int *find_first_even(const int *values, size_t count) {
    for (size_t index = 0; index < count; ++index) {
        if (values[index] % 2 == 0) {
            return &values[index];
        }
    }
    return NULL;
}

int main(void) {
    const int readings[] = {11, 17, 24, 31};
    const size_t count = sizeof readings / sizeof readings[0];
    const int *found = find_first_even(readings, count);

    if (found != NULL) {
        printf("index: %td\n", found - readings);
        printf("value: %d\n", *found);
    }
    return 0;
}

index: 2
value: 24

found - readings 有定义，因为两个指针都指向同一个数组。结果类型是 ptrdiff_t，所以 printf 使用 %td。如果函数返回后数组已经结束生命周期，这个减法与解引用都不再成立。

返回 const int * 保留了输入的只读约束。若生成代码把返回类型改成 int *，它既会丢弃限定，也会向调用方承诺并不存在的写权限。

用二级指针更新选择结果

select_slot 需要修改调用方的 selected 指针，所以接收 int **。失败路径在写入 *selection 之前返回，因而保持调用方原来的选择。

#include <stddef.h>
#include <stdio.h>

static int select_slot(int **selection,
                       int *slots,
                       size_t count,
                       size_t index) {
    if (selection == NULL || index >= count || slots == NULL) {
        return 0;
    }

    *selection = &slots[index];
    return 1;
}

int main(void) {
    int slots[] = {10, 20, 30};
    int *selected = NULL;

    printf("selected: %d\n", select_slot(&selected, slots, 3, 1));
    *selected += 5;
    printf("value: %d\n", *selected);
    printf("invalid: %d\n", select_slot(&selected, slots, 3, 8));
    printf("preserved: %d\n", *selected);
    return 0;
}

selected: 1
value: 25
invalid: 0
preserved: 25

调用处的 &selected 是 int **，而 slots 转换为首元素 int *。成功后，selected 借用数组的第二个元素；它不能比 slots 数组活得更久。

二级指针不自动表示拥有关系。这里只更新一个借用结果，没有分配也没有释放。若接口通过 int ** 交付动态对象，还必须另行规定释放责任和失败时的状态。

陷阱

返回局部对象的地址

修复方法： 让调用方提供存储，返回拥有型对象，或使用生命周期足够长的明确所有者。不要用 static 机械修补；它会把状态变成所有调用共享，并引入重入与并发问题。

把非空当作有效证明

修复方法： 从所有者和控制流证明生命周期，从指针与长度证明边界，并通过类型化接口保存对齐和访问类型。空值检查只用于契约确实允许为空的边界。

从指针恢复数组长度

修复方法： 同时传递元素数或结束指针，并明确单位是元素还是字节。只有在数组类型仍然存在的作用域中，sizeof array / sizeof array[0] 才能计算元素数。

用强制转换掩盖限定或类型错误

修复方法： 修正生产者与消费者的声明，使类型和可变性在边界上一致。必须解析字节表示时，先验证长度并使用标准允许的字符类型访问或 memcpy，不要把一次转换当作验证。

释放后只清空一个别名

修复方法： 设计一个明确拥有者和单一释放路径，限制借用的传播范围，并在释放前让所有使用完成。置空可以防止当前变量被重复使用，但不能替代所有权设计。

延伸阅读

• ISO/IEC 9899:2024 工作草案 N3220
• cppreference：指针声明
• SEI CERT C：ARR30-C 不形成或使用越界指针与数组下标
• GCC 13.3：程序检测选项