课件用一段 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 = 30 | p = &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;
}
调试器把原因摆得更清楚。a、b 在 main 的栈帧里,x、y 在 Swap1 的栈帧里,四个变量值相同、地址各不相同:

想让函数改到 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 才是改地址里的内容。审查这类代码时,看到赋值先分清改的是箭头,还是箭头指向的东西;想改调用者的指针变量本身,得把那个指针变量的地址传进来,这就是二级指针要解决的问题。
还没有评论 — 第一条由你来留。