内存是一排编了号的字节

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

内存被切成等大的字节单元,编号从 0x00000000 一直排到 0xFFFFFFFF

编号的范围由地址线数量决定:32 根地址线,每根两种状态,能表示 2^32 个编号,对应 4 GB 的字节空间。这也是 32 位程序最多只能直接寻址 4 GB 的原因。64 位平台的地址是 64 个二进制位,实际可用的宽度由硬件和操作系统决定。

存储单位按 1024 递进:

单位换算
bit一个二进制位
Byte1 Byte = 8 bit
KB1 KB = 1024 Byte
MB1 MB = 1024 KB
GB1 GB = 1024 MB
TB1 TB = 1024 GB
PB1 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;
}

内存窗口里的 a:从 0x006FFD70 开始依次是 0a、00、00、00,四个字节拼成十进制的 10

十进制的 10 在内存里写成 0a 00 00 00 四个字节,没有哪一格直接写着“10”。低字节排在低地址,这是 x86 的小端序。知道起始地址之后,编译器按 int 的宽度往后数四个字节,整个变量才算完整:

变量 a 横跨 0x006FFD70 到 0x006FFD73,&a 返回其中最小的 0x006FFD70

把地址存下来,就有了指针变量:

int a = 10;
int *pa = &a;

pa 里存的是 a 的地址,箭头从 pa 指向 a;pa 本身的类型是 int*,a 的类型是 int

读 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 和 pi 指向同一个地址,pc+1 只大 1,pi+1 大了 4

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;     /* 同上 */

VS 对 void* 解引用的报错:C2100 非法的间接寻址,这两行根本编不过

课件的文字结论(能接地址、不能直接参与运算)没错,但它配的代码演示的是解引用,错在 *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 指向别处。