内存是一排编了号的字节
内存被切成一个个单元,每个单元一个字节,每个单元有编号。CPU 要读写某个字节,先把这个编号通过地址总线发出去,内存按编号找到对应的单元,再把数据放回数据总线。

编号的范围由地址线数量决定:32 根地址线,每根两种状态,能表示 2^32 个编号,对应 4 GB 的字节空间。这也是 32 位程序最多只能直接寻址 4 GB 的原因。64 位平台的地址是 64 个二进制位,实际可用的宽度由硬件和操作系统决定。
存储单位按 1024 递进:
| 单位 | 换算 |
|---|---|
| bit | 一个二进制位 |
| Byte | 1 Byte = 8 bit |
| KB | 1 KB = 1024 Byte |
| MB | 1 MB = 1024 KB |
| GB | 1 GB = 1024 MB |
| TB | 1 TB = 1024 GB |
| PB | 1 PB = 1024 TB |
编号在 C 里叫地址。指针是“带类型的地址”——既可以是类型(int *),也可以是变量(存放地址的变量)。课件写“内存单元的编号 == 地址 == 指针”,前两个等号成立,第三个少了“类型”这层信息,后面马上会看到它为什么重要。
&a 给出的是四个字节里最小的那个编号
int a = 10; 向内存申请 4 个字节,这 4 个字节各有各的编号,但 &a 只给你一个:最小的那个。
#include <stdio.h>
int main(void)
{
int a = 10;
printf("%p\n", (void *)&a); /* 比如 0x006FFD70 */
return 0;
}
十进制的 10 在内存里写成 0a 00 00 00 四个字节,没有哪一格直接写着“10”。低字节排在低地址,这是 x86 的小端序。知道起始地址之后,编译器按 int 的宽度往后数四个字节,整个变量才算完整:

把地址存下来,就有了指针变量:
int a = 10;
int *pa = &a;
读 int * pa 的方式是:* 说明 pa 是指针变量,前面的 int 说明它指向一个 int。char ch = 'w'; 的地址就该放进 char *pc,因为指向的对象是 char。
拿到地址之后,用解引用操作符 * 找到那块空间:
int a = 100;
int *pa = &a;
*pa = 0; /* 等价于 a = 0 */*pa 就是 a 这块空间本身,给它赋值等于改 a。指针的价值在于“改一个变量多了一条途径”:函数拿不到调用者的变量,但能拿到它的地址。
类型决定两件事:一次读几个字节,一步走多远
同一块内存,用不同类型的指针去指,能做的事不同。下面两段代码只差指针类型:
#include <stdio.h>
int main(void)
{
int n1 = 0x11223344;
int n2 = 0x11223344;
int *pi = &n1;
char *pc = (char *)&n2;
*pi = 0; /* 四个字节全部写成 0 */
*pc = 0; /* 只改最低地址那一个字节 */
printf("%08X %08X\n", n1, n2); /* 00000000 11223300 */
return 0;
}*pi = 0 把 n1 整个清空;*pc = 0 只改了最低字节,小端序下最低字节存放的是 0x44,所以 n2 变成 0x11223300。解引用能碰几个字节,由指针指向的类型决定,这叫访问宽度。
步长是同一件事的另一面:
#include <stdio.h>
int main(void)
{
int n = 10;
char *pc = (char *)&n;
int *pi = &n;
printf("&n = %p\n", (void *)&n);
printf("pc = %p\n", (void *)pc);
printf("pc+1 = %p\n", (void *)(pc + 1));
printf("pi = %p\n", (void *)pi);
printf("pi+1 = %p\n", (void *)(pi + 1));
return 0;
}
pc + 1 大 1 字节,pi + 1 大 4 字节。p + i 实际算的是“起始地址 + i × sizeof(*p)”,所以指针加一表示跳到下一个同类型的对象,地址增加值取决于类型宽度;p - 1 同理,后退一个元素。
这也解释了为什么类型不匹配的赋值编译器要警告:
int a = 10;
char *pc = &a; /* warning C4133: 从 "int *" 到 "char *" 类型不兼容 */强转能把这行压下去,但一解引用就只改一个字节,看起来“只改了一点点”,实际上半个变量已经坏了。
指针多大,只看目标平台
#include <stdio.h>
int main(void)
{
printf("%zu\n", sizeof(char *));
printf("%zu\n", sizeof(short *));
printf("%zu\n", sizeof(int *));
printf("%zu\n", sizeof(double *));
return 0;
}32 位目标上四行全是 4,64 位目标上全是 8。指针大小和它指向的类型无关,因为存的只是一个地址;地址有多宽,指针就有多大。
课件这段用的是 printf("%zd\n", sizeof(char *));。sizeof 的结果类型是 size_t,无符号;%zd 是对应有符号版本(ptrdiff_t / ssize_t)的格式符,拿它输出 size_t 在标准上属于未定义行为,在 MSVC 上会给出格式不匹配的警告。正确写法是 %zu。
还要注意“32 位 / 64 位”指的是编译目标,不是这台电脑。64 位 Windows 上把解决方案平台切成 x86,编出来的程序里指针仍然是 4 字节;切回 x64 才是 8 字节。
void * 能收任何地址,但自己不能动手
void * 是“不知道指向什么类型”的指针。C 标准规定,任何对象指针都能隐式转成 void *,void * 也能隐式转回具体类型指针,所以 malloc 的返回值可以直接赋给 int *:
#include <stdlib.h>
void f(void)
{
int *p = malloc(sizeof(int) * 10); /* C 里不需要强转 */
if (p != NULL)
{
p[0] = 1;
}
free(p);
}void * 的局限正好来自“不知道类型”:解引用时不知道读几个字节,加减时不知道一步多远,所以这两件事都不允许。课件想演示这一点,却写成了:
int a = 10;
void *pa = &a;
void *pc = &a;
*pa = 10; /* 标准 C 不合法 */
*pc = 0; /* 同上 */
课件的文字结论(能接地址、不能直接参与运算)没错,但它配的代码演示的是解引用,错在 *pa = 10 这一行;解引用和指针运算这两件事,标准都不允许 void * 直接做。正确做法是先转回具体类型:
*(int *)pa = 20;GCC 和 Clang 把 void * + 1 解释成按字节加一,那是编译器扩展;MSVC 直接拒绝。代码里最好当成“void * 什么都不能干,除了接地址和转类型”。
它真正的位置在接口上。qsort 不知道要排什么类型,只收基地址、元素个数、每个元素多大,外加一个比较回调,回调参数也是两个 const void *,由使用者转成真正的类型再比较。C 的泛型就靠这一套。
C 和 C++ 在这里还有差别:C 允许 void * 隐式转成 int *,C++ 要求强转。同一份代码复制到 .cpp 里报错,多半是这个原因。
野指针,和指针运算不能越过的线
野指针指“指向的地址不可预期或已经失效”的指针。三种来源最常见。
第一种,声明了没初始化:
void f(void)
{
int *p; /* p 里是未确定的地址 */
*p = 10; /* 往一个不知道哪里的地址写数据 */
}局部指针变量和普通局部变量一样,不初始化就是不确定的值。声明时给 NULL,或者直接指向一个真实对象,可以把这个坑堵死。
第二种,指向已经释放的内存(悬空指针):
#include <stdlib.h>
void f(void)
{
int *p = malloc(sizeof(int));
free(p);
*p = 20; /* p 指向的空间已经还给堆管理器 */
p = NULL; /* 释放之后立刻置空,下次解引用多半会直接崩,而不是改坏数据 */
}第三种,返回局部变量的地址:
int *bad(void)
{
int x = 10;
return &x; /* 函数返回后 x 的栈帧已经失效 */
}x 的地址在函数返回后随时会被下一次调用覆盖,拿到手里就已经不可靠。要返回长期有效的数据,用 malloc、静态变量,或者由调用者传缓冲区进来。
指针的加减也有边界。标准只对“指向数组元素的指针”定义了这些运算,合法范围是 arr 到 arr + n,其中 arr + n 是尾后指针:
#include <stdio.h>
int main(void)
{
int arr[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
int *p = arr;
int *end = arr + 10; /* 合法:可以形成,可以比较,不能解引用 */
while (p < end)
{
printf("%d ", *p);
p++;
}
return 0;
}arr + 11 连形成都不合法;解引用 end 是越界;两个不同数组的指针相减、比大小,标准没有定义。
指针减指针得到的是“隔了几个元素”,不是字节差:
#include <stdio.h>
#include <stddef.h>
ptrdiff_t my_strlen(const char *s)
{
const char *p = s;
while (*p != '\0')
{
p++;
}
return p - s;
}
int main(void)
{
printf("%td\n", my_strlen("abc")); /* 3 */
return 0;
}对 char *,字节差和元素差恰好相等,看起来像“减出长度”;换成 int *,字节差 12 对应的结果是 3。结果的类型是 ptrdiff_t,有符号,因为后面的指针减前面的可能是负数。课件把返回值写成 int,长度超过 INT_MAX 时会截断;用 ptrdiff_t 才和指针宽度一致。
*(p + i) 与 p[i] 等价,遍历数组两种写法都能用;前者显式写出了“先加偏移、再解引用”,读指针运算时更直观。
p * 2、p + q 都不合法:两个地址相加没有意义。想按字节挪动,先转成 unsigned char *,并确认转回来时的地址仍然对齐。
const 在 * 的左边还是右边
const 修饰指针有四种写法,只有三种含义:
const int *p1 = &a; /* 指向的值只读,p1 本身可改 */
int const *p2 = &a; /* 与上一行完全等价 */
int * const p3 = &a; /* 指针本身只读,*p3 可改 */
const int * const p4 = &a; /* 值和指针都只读 */读法是从变量名往左看,const 贴着谁就锁谁:
const int *p1:const修饰int,所以*p1不能改,p1 = &b可以。int * const p3:const紧挨p3,所以p3不能改,*p3 = 20可以。- 两个
const都在,两件事都不能做。
*p1 = 20; /* 编译错误:给只读对象赋值 */
p3 = &b; /* 编译错误:给只读变量赋值 */
*p3 = 20; /* 合法 */这两种“只读”都是编译期的约束,靠编译器检查,不是运行时保护。真要把 const 对象改掉,用强制类型转换可以绕过检查,但那是未定义行为。
函数参数里最常用的是第一种:void print_str(const char *s) 承诺“我只读这块字符串,不改它”,调用者传字符串字面量、传普通数组都放心。第二种适合“缓冲区地址固定、内容可变”的场合,比如 char * const buf = malloc(64);,防止函数中途把 buf 指向别处。
还没有评论 — 第一条由你来留。