课件用一段 const int n = 0; int *p = &n; *p = 20; 的代码说明 const 可以被人从地址那头绕过去,控制台也确实打出了 n = 20。这段程序能编译、能跑,但 int *p = &n 这一行已经把 const 丢了,编译器通常会给一条 discards 'const' qualifier 的警告;*p = 20 则是对一个 const 对象的修改。标准对这件事的规定是未定义行为,不是“虽然违规但一定成功”。打印出 20,只说明这次运行的优化器没有把 n 折叠成立即数。

const 限定的是访问权限

const int n = 0; 里的 n 仍然是变量,仍然占一块存储,只是它的类型带了 const 限定。编译器拒绝 n = 20,因为通过 n 这个左值写入不符合类型规则;这不等于那块内存在硬件上不可写。栈上的 const 变量通常就在可写的栈页里,.rodata 里的常量才由操作系统映射成只读。

C11 6.7.3 的语义部分写得很直接:通过一个非 const 限定的左值去修改一个定义为 const 的对象,行为未定义。编译器可以据此假设“它不会变”,把这个值折叠进指令、把重复读取合并掉。绕过去的写入和这个假设冲突,结果就不再由源码决定:

#include <stdio.h>
 
int main(void)
{
    const int n = 0;
    int *p = (int *)&n;      /* 强转能消除警告,消不掉未定义行为 */
 
    *p = 20;
    printf("%d\n", n);       /* 可能是 20,也可能是 0 */
    return 0;
}

不要拿这段代码验证“const 没用”。它验证的只是某一次编译、某一个优化级别下的巧合。

C 里 const 变量还不是常量表达式,不能当 case 标签,也不能初始化静态存储期的对象。那种场景要用 #define、枚举,或者 C23 的 constexpr。

const 在星号左边还是右边

const 修饰指针变量时,位置决定它约束哪一层:

int *p;                  /* 指针可改,指向的内容也可改 */
const int *p;            /* 指向的内容只读,指针本身可改 */
int * const p;           /* 指针本身只读,指向的内容可改 */
const int * const p;     /* 两层都只读 */

const int *p 和 int const *p 是同一个类型,const 贴着 int 还是贴着 * 的左边都算修饰被指向的对象。判断时从变量名往外读:p 先和 * 结合,说明它是指针;再看 * 左侧有没有 const,决定能不能写 *p;看 * 右侧有没有 const,决定能不能写 p = &other。

声明*p = 30p = &m锁住的对象
int *p合法合法无
const int *p编译错误合法*p
int * const p合法编译错误p
const int * const p编译错误编译错误两者
#include <stdio.h>
 
int main(void)
{
    int n = 10;
    int m = 20;
 
    const int *p1 = &n;
    int * const p2 = &n;
    const int * const p3 = &n;
 
    p1 = &m;          /* 改指针,允许 */
    *p2 = 30;         /* 改内容,允许 */
 
    printf("%d %d %d\n", *p1, *p2, *p3);   /* 20 30 10 */
    return 0;
}

int * const p2 在 C 里可以不初始化,但之后永远没有机会再赋值,这个变量等于废的;C++ 直接拒绝这种写法。写成 int * const p2 = &n; 才符合本意。

形参上的 const 更容易写反。void f(int * const arr) 锁的是“形参 arr 这个指针不能再指向别处”,它指向的数组照样能改;想表达“函数不修改调用者的数组”,要写 const int *arr。只差一个词的位置,保护的是完全不同的东西。

野指针:地址还在,对象已经不在了

野指针(wild pointer)指指针里存的地址不对应一个当前有效的对象,可能是未初始化留下的栈垃圾、数组边界之外的地址,或者已经被释放的空间。三种来路对应三种写法:

#include <stdio.h>
#include <stdlib.h>
 
int *Bad(void)
{
    int n = 100;
    return &n;           /* 函数返回后,n 的栈空间失效 */
}
 
int main(void)
{
    int *p;              /* 未初始化,值是不确定的 */
    *p = 20;             /* 未定义行为 */
 
    int arr[10] = {0};
    int *q = arr;
    int i;
 
    for (i = 0; i <= 11; i++)     /* 越界:循环写了 12 个元素 */
    {
        *(q++) = i;
    }
 
    int *r = Bad();
    printf("%d\n", *r);           /* 地址还在,对象已经没了 */
 
    int *s = malloc(sizeof(int));
    free(s);                      /* s 变成悬空指针,值没有被清掉 */
    return 0;
}

课件的越界示例本身就多写了两个元素:arr 只有 10 个格子,i <= 11 让 q 走到 arr + 11。这个循环不是“演示越界”,它真的在越界写。

规避手段可以归成四条:

  • 声明时就给定去向。知道指向谁就写 int *p = &n;,暂时不知道就写 int *p = NULL;。
  • 下标和指针算术都不越过对象边界。arr + 10 是尾后位置,可以比较,不能解引用;arr + 11 连比较都不合法。
  • 不再使用某个指针时置 NULL,每次解引用前先判空。free(s) 之后立刻 s = NULL;,比记住“这个指针已经释放过”可靠。
  • 不返回局部变量的地址。需要长期有效的地址,用调用者传入的缓冲区、static 局部变量或者堆内存;static 局部变量只有一份,两次调用会互相覆盖,也不是线程安全的。

课件把 NULL 写成“标识符常量,值是 0,0 也是地址,这个地址无法使用”。更准确的说法是:NULL 是实现定义的空指针常量,<stddef.h> 在 C 里通常把它定义成 ((void *)0),C++ 那边可能是 0。标准只保证它和任何有效对象的地址都不相等,没有规定“0 号地址在硬件上读不了”。主流系统把低地址页设成不可访问,所以解引用空指针多半段错误,但那是操作系统的安排。

判空也只挡得住空指针。越界指针、悬空指针都不是 NULL,照样能通过 if (p != NULL)。真正的安全来自所有权清楚:谁分配、谁释放、释放之后还有谁持有这个地址。

assert 是运行期检查,NDEBUG 会把整行删掉

assert 是 <assert.h> 里的宏,接受一个标量表达式。表达式为真时什么都不做;为假时向 stderr 打印未通过的表达式原文、文件名和行号,然后调用 abort()。

#include <stdio.h>
#include <assert.h>
 
int main(void)
{
    int *p = NULL;
 
    assert(p != NULL);       /* 失败时打印表达式、文件、行号并终止 */
    printf("%d\n", *p);
    return 0;
}

关掉断言的办法是在包含 <assert.h> 之前定义 NDEBUG:

#define NDEBUG
#include <assert.h>

定义了 NDEBUG 之后,assert(condition) 展开成 ((void)0),表达式根本不会求值。这条规则带来一个常见的坑:

#include <stdio.h>
#include <assert.h>
 
int main(void)
{
    int i = 0;
 
    assert(i++ < 10);       /* 有 NDEBUG 时 i 不会自增 */
    printf("i = %d\n", i);  /* Debug 下是 1,Release 下是 0 */
    return 0;
}

断言里只放纯判断,不要把赋值、自增、函数调用塞进去。它每次执行都要多做一次判断,Debug 下有开销,适合排查问题,不适合放在高频循环里。

课件说“在 VS 这样的集成开发环境中,Release 版本直接就是优化掉了”。机制要说准:VS 的 Release 配置预定义了 NDEBUG,所以断言在预处理阶段就没了;换成 GCC,如果编译命令里没有 -DNDEBUG,Release 优化并不会自动删除断言。是否启用由 NDEBUG 决定,不由 -O2 决定。

用不用断言,取决于错误来源。调用者传了空指针、程序进入了不可能的状态、内部数组下标越界,这些是程序写错了,适合 assert;malloc 失败、文件打不开、用户输入非法,这些是运行环境随时会发生的,必须用 if 判断并返回错误码。断言在发布版会被删掉,拿它处理 malloc 失败,等于发布版放弃处理。编译期就能确定的条件,可以用 C11 的 _Static_assert,它失败时直接停止编译,也不受 NDEBUG 影响。

字符串长度和一次失败的 Swap

strlen 的标准原型是:

size_t strlen(const char *str);

它从 str 指向的地址开始向后数,数到 \0 为止,不把 \0 算进长度。参数是 const char *,说明函数只读,不会改调用者的字符串。课件的模拟实现写成了 int my_strlen(const char *str),返回类型和标准对不上:int 在超长字符串上可能溢出,溢出后的结果没有定义,应该用 size_t,打印用 %zu。

#include <stdio.h>
#include <assert.h>
 
size_t MyStrlen(const char *str)
{
    const char *p = str;
 
    assert(str != NULL);
 
    while (*p != '\0')
    {
        p++;
    }
    return (size_t)(p - str);
}
 
int main(void)
{
    printf("%zu\n", MyStrlen("abcdef"));   /* 6 */
    printf("%zu\n", MyStrlen(""));         /* 0 */
    return 0;
}

p - str 的结果类型是 ptrdiff_t,有符号;长度不可能为负,转成 size_t 是为了和标准接口一致。空串时两个指针都停在 '\0' 上,差是 0,这个边界不用单独判断。

传参方式接着在这段代码上落地。下面这个 Swap1 想交换两个整数:

#include <stdio.h>
 
void Swap1(int x, int y)
{
    int tmp = x;
    x = y;
    y = tmp;
}
 
int main(void)
{
    int a = 10;
    int b = 20;
 
    Swap1(a, b);
    printf("交换前:a=%d b=%d\n", a, b);
    printf("交换后:a=%d b=%d\n", a, b);   /* 仍然是 10 20 */
    return 0;
}

控制台里输入 10 20,Swap1 调用前后 a、b 都没有变化:函数交换的是形参副本,main 里的两个变量没有被触碰

调试器把原因摆得更清楚。a、b 在 main 的栈帧里,x、y 在 Swap1 的栈帧里,四个变量值相同、地址各不相同:

监视窗口里 a 和 x 都是 10,b 和 y 都是 20,但 &a、&b 与 &x、&y 的地址不同:调用发生时形参在栈上新开了一份空间

想让函数改到 main 里的变量,只能把地址传进去:

#include <stdio.h>
 
void Swap2(int *px, int *py)
{
    int tmp = *px;
    *px = *py;
    *py = tmp;
}
 
int main(void)
{
    int a = 10;
    int b = 20;
 
    Swap2(&a, &b);
    printf("a=%d b=%d\n", a, b);   /* 20 10 */
    return 0;
}

px、py 仍然是值传递,复制的是 &a、&b 这两个地址。变化在于副本的内容是地址,函数顺着地址找到 main 的变量,于是写得进去。所谓“传址调用”没有推翻“C 只有传值调用”,它只是把传的东西换成了地址。

还有一种看着对、实际什么都没换的写法:

void SwapWrong(int *px, int *py)
{
    int *tmp = px;
 
    px = py;        /* 改的是形参指向谁,a 和 b 没动 */
    py = tmp;
}

参数类型挑不出毛病,函数体改的却是“指针自己指向哪”。*px = *py 才是改地址里的内容。审查这类代码时,看到赋值先分清改的是箭头,还是箭头指向的东西;想改调用者的指针变量本身,得把那个指针变量的地址传进来,这就是二级指针要解决的问题。