C语言初阶 11:地址、指针类型与指针运算
- 1C语言初阶 01:初识 C 语言与第一个程序
- 2C语言初阶 02:数据类型、变量、常量与字符
- 3C语言初阶 03:常见操作符与表达式求值
- 4C语言初阶 04:分支、循环与流程控制
- 5C语言初阶 05:用猜数字游戏串起分支与循环
- 6C语言初阶 06:一维数组、二维数组与字符串
- 7C语言初阶 07:函数设计、传参与多文件程序
- 8C语言初阶 08:从零组织命令行扫雷项目
- 9C语言初阶 09:用调试器定位错误与观察内存
- 10C语言初阶 10:函数递归、调用展开与递归的代价
- 11C语言初阶 11:地址、指针类型与指针运算本文
- 12C语言初阶 12:用结构体描述复杂对象
- 13C语言进阶 13:进制、补码、字节序与位运算
- 14C语言进阶 14:数组名、数组指针与二维数组传参
- 15C语言进阶 15:动态内存、realloc 与柔性数组
- 16C语言进阶 16:函数指针、回调与通用排序
- 17C语言进阶 17:指针的边界、const、断言与所有权
- 18C语言进阶 18:字符与字符串函数的完整使用规则
- 19C语言进阶 19:memcpy、memmove、memset 与 memcmp
- 20C语言进阶 20:结构体嵌套、自引用、对齐与位域
- 21C语言进阶 21:联合体、枚举与带标签的数据模型
- 22C语言进阶 22:从源代码到可执行文件的编译链接过程
- 23C语言进阶 23:宏、条件编译与预处理陷阱
- 24C语言进阶 24:文件读写、错误处理与数据持久化
代码块包含可运行实现、局部片段、输出、故意出错的示例与思考题;它们是独立示例,请结合上下文阅读,不能将整章拼成一个程序。
阅读前先核对
- 指针大小由实现/ABI 决定,不能把所有指针在所有环境中统一规定为 4 或 8 字节。打印对象地址用
%p并转换为void *。 - 指针加减和大小比较有数组范围限制,尾后指针可形成但不能解引用;
void *在标准 C 中不能直接做算术或解引用。
本章目标
-
理解指针的本质就是地址
-
理解指针类型的意义,能够使用正确的指针类型
-
指针的运算的本质就是地址的偏移
-
掌握传值调用和传址调用的区别
-
掌握二级指针
-
为后续指针进阶打好基础
1. 内存和地址
学习指针必须先理解内存和地址。
在讲解之前,先看一个生活中的案例:
假设有一栋宿舍楼,把你放在楼里,楼上有100个房间,但是房间没有编号,你的一个朋友来找你玩,如果想找到你,就得挨个房子去找,这样效率很低,但是我们如果根据楼层和楼层的房间的情况,给每个房间编上号,如:
课件代码 11-001 · PDF 第 1 页
一楼:101,102,103...二楼:201,202,203......有了房间号,如果你的朋友得到房间号,就可以快速的找房间,找到你。


生活中,每个房间有了房间号,就能提高效率,能快速地找到房间。
如果把上面的例子对照到计算机中,又是怎么样呢?
计算机上CPU(中央处理器)在处理数据的时候,需要的数据是在内存中读取的,处理后的数据也会放回内存中。
常见的一台电脑上内存是 8GB/16GB/32GB 等,那这些内存空间如何高效的管理呢?
解决办法和上面的例子相似,把内存划分为一个个的内存单元,每个内存单元的大小取1个字节,然后给每一个内存单元一个编号,就类似于房间编号。

计算机中常见的单位介绍:
一个比特位可以存储一个2进制的位1或者0代码块 代码块
课件代码 11-002 · PDF 第 2,3 页
bit - 比特位Byte - 字节KBMBGBTBPB课件代码 11-003 · PDF 第 2,3 页
1Byte = 8bit1KB = 1024Byte1MB = 1024KB1GB = 1024MB1TB = 1024GB1PB = 1024TB...
其中,每个内存单元,相当于一个学生宿舍,一个字节空间里面能放8个比特位,就好比同学们住的八人间,每个人是一个比特位。
每个内存单元也都有一个编号(这个编号就相当于宿舍房间的门牌号),有了这个内存单元的编号,CPU就可以快速找到一个内存空间。
生活中我们把门牌号也叫地址,在计算机中我们把内存单元的编号也称为地址。C语言中给地址起了新的名字叫:指针。
所以我们可以理解为:
内存单元的编号 == 地址 == 指针
🎈 注意上面我们是为了方便讲解,对真实的内存访问进行了简化的,实际上我们编写的运行在
X86架构的计算机上的C语言程序,是不会直接访问物理内存的。
程序运行时为变量分配的地址,在程序调试过程中,我们看到的地址都是虚拟地址;虚拟地址不是物理地址。虚拟地址是虚拟地址空间中的地址。
虚拟地址空间可以看作操作系统为每个程序提供的一个“假想的、独占的、连续的内存空间”。
程序中的虚拟地址,会由CPU的内存管理单元(MMU)映射到物理内存中,其实程序最终还是会访问物理内存的。这个由虚拟地址换成物理地址的过程,暂时我们不需要关心,学习到操作系统的知识,慢慢再理解就可以了。

我们在学习编程语言的时候,都是在使用虚拟地址的。
🎈 是否存在C程序直接使用物理内存的情况?
有,但属于非常特殊的领域:
- 嵌入式系统:没有MMU(叫单片机或MCU,如ARM Cortex-M系列、Arduino)。C程序
直接使用物理地址。此时,编译器和程序员要亲自管理整个内存布局。
- 操作系统内核:内核拥有最高权限,它可以访问物理地址。
2. 指针变量和地址
2.1 取地址操作符(&)
理解了内存和地址的关系,我们再回到C语言,在C语言中创建变量其实就是向内存申请空间,比如:
X86环境
课件代码 11-004 · PDF 第 4,5 页
#include <stdio.h>int main(){ int a = 10; return 0;}

比如,上述的代码就是创建了整型变量a,内存中申请4个字节,用于存放整数10,其中每个字节都有地址,上图中4个字节的地址分别是:
课件代码 11-005 · PDF 第 5 页
0x006FFD700x006FFD710x006FFD720x006FFD73那我们如何能得到a的地址呢?
这里就得学习一个操作符(&)-取地址操作符X86环境
课件代码 11-006 · PDF 第 5 页
#include <stdio.h>int main(){ int a = 10; &a;//取出a的地址 printf("%p\n", &a); return 0;}按照我画图的例子,会打印出来:006FFD70&a取出的是a所占4个字节中地址较小的字节的地址。
虽然整型变量占用4个字节,我们只要知道了第一个字节地址,顺藤摸瓜访问到4个字节的数据也是可行的。
2.2 指针变量
2.2.1 指针变量和初始化
那我们通过取地址操作符(&)拿到的地址是一个数值,比如: 0x006FFD70 ,这个数值有时候也是需要存储起来,方便后期再使用的,那我们把这样的地址值存放在哪里呢?答案是:指针变量中。
比如:
课件代码 11-007 · PDF 第 6 页
#include <stdio.h>int main(){ int a = 10; int * pa = &a;//取出a的地址并存储到指针变量pa中
return 0;}🎈 指针变量也是一种变量,这种变量就是用来存放地址的,存放在指针变量中的值都会理解为
地址。
这里我们是拿 &a (也就是a的地址)给 pa 进行了初始化。
有时候我们创建了一个指针变量,但是暂时不需要指向变量,可以使用 NULL 来初始化, NULL 是C语言中定义的一个标识符常量,值是0,0也是地址,这个地址是无法使用的,读写该地址会报错。
课件代码 11-008 · PDF 第 6 页
#ifdef __cplusplus #define NULL 0#else #define NULL ((void *)0)#endif一个指针变量被初始化为 NULL ,意思就是这个指针变量暂时不指向任何有效的内存位置,等后续使用的时候,可以给赋值新的地址。
使用 NULL 初始化指针变量:
课件代码 11-009 · PDF 第 6 页
int main(){ int *pa = NULL; return 0;}❓ 那如果一个指针变量没有初始化,会怎样呢?
-
指针变量如果是全局的,则默认会被初始化0,也就是NULL指针。
-
指针变量如果是局部的,则指针变量的值是未知的,这样的指针就是野指针;强制使用野指针会导
致非法访问内存,程序崩溃。
2.2.2 如何拆解指针类型
我们看到 pa 的类型是 int* ,我们该如何理解指针的类型呢?
课件代码 11-010 · PDF 第 7 页
int a = 10;int* pa = &a;这里 pa 左边写的是 int* , int* 是 pa 的类型;但是 * 和 int 应该分开理解。
* 是在说明 pa 是指针变量,而前面的 int 是在说明 pa 指向的是整型 int 类型的对象。

那如果有一个char类型的变量ch,ch的地址,要放在什么类型的指针变量中呢?
课件代码 11-011 · PDF 第 7 页
char ch = 'w';pc = &ch;//pc 的类型怎么写呢?2.2.3 解引用操作符
在现实生活中,我们使用地址要找到一个房间,在房间里可以拿去或者存放物品。
程序中我们将地址保存起来,未来是要使用的,那怎么使用呢?
C语言中其实也是一样的,我们只要拿到了地址(指针),就可以通过地址(指针)找到地址(指针)指向的对象,这里必须学习一个操作符叫解引用操作符( * )。
课件代码 11-012 · PDF 第 8 页
#include <stdio.h>
int main(){ int a = 100; int* pa = &a; *pa = 0; return 0;}上面代码中第7行就使用了解引用操作符, *pa 的意思就是通过 pa 中存放的地址,找到 pa 指向的空间,*pa其实就是a变量了;所以*pa = 0,这个操作符是把a改成了0。
有同学肯定在想,这里如果目的就是把 a 改成 0 的话,写成 a = 0; 不就完了,为啥非要使用指针呢?
其实这里是把 a 的修改交给了 pa 来操作,这样对 a 的修改,就多了一种的途径,写代码就会更加灵活,后期慢慢就能理解了。
2.3 指针变量的大小
C语言标准并未规定指针变量的长度,我们现在分别在VS2026的,X86和X64环境下测试:
课件代码 11-013 · PDF 第 8 页
#include <stdio.h>int main(){ printf("%zd\n", sizeof(char *)); printf("%zd\n", sizeof(short *)); printf("%zd\n", sizeof(int *)); printf("%zd\n", sizeof(double *)); return 0;}

X86环境输出结果 X64环境输出结果其实指针变量的大小是取决于数据模型的,下面列出了常见的4个数据模型:
数据模型指的是在特定操作系统、CPU 架构和 ABI(应用程序二进制接口)下,C/C++ 等语言中基本整数类型( short 、 int 、 long 、 long long )以及指针类型的具体位宽(字节数) 的约定。

结论:
-
32位平台下地址是32个bit位,指针变量大小是4个字节
-
64位平台下地址是64个bit位,指针变量大小是8个字节
-
注意指针变量的大小和类型是无关的,只要是指针类型的变量,在相同的平台下,大小都是相同
的。
3. 指针类型的意义
指针变量的大小和类型无关,只要是指针变量,在同一个平台下,大小都是一样的,为什么还要有各种各样的指针类型呢?
其实指针类型是有特殊意义的,我们接下来继续学习。
3.1 指针解引用
对比,下面2段代码,主要在调试时观察内存的变化。
代码块 代码块
课件代码 11-014 · PDF 第 10 页
//代码1#include <stdio.h>
int main(){ int n = 0x11223344; int *pi = &n; *pi = 0; return 0;}课件代码 11-015 · PDF 第 10 页
//代码2#include <stdio.h>
int main(){ int n = 0x11223344; char *pc = (char *)&n; *pc = 0; return 0;}调试可见,代码1会将 n 的4个字节全部改为0,但是代码2只是将 n 的第一个字节改为0。
结论:指针的类型决定了,对指针解引用的时候有多大的权限(一次能操作几个字节)。
比如: char* 的指针解引用就只能访问一个字节,而 int* 的指针的解引用就能访问四个字节。
3.2 指针+-整数
先看一段代码,调试观察地址的变化。
课件代码 11-016 · PDF 第 10 页
#include <stdio.h>int main(){ int n = 10; char *pc = (char*)&n; int *pi = &n;
printf("%p\n", &n); printf("%p\n", pc); printf("%p\n", pc+1); printf("%p\n", pi); printf("%p\n", pi+1); return 0;}代码运行的结果如下:

x86环境结果我们可以看出, char* 类型的指针变量 +1 跳过 1 个字节, int* 类型的指针变量 +1 跳过了 4个字节。这就是指针变量的类型差异带来的变化。
-
指针 +1 ,其实跳过 1 个指针指向的元素,所以指针 +n ,就是跳过 n 个指针指向的元素。
-
指针可以 +n ,那也可以 -n 。
结论:指针的类型决定了指针向前或者向后走一步走多大(距离)。
指针+-整数,让指针可以在内存中向前或者向后移动,这就为使用指针访问内存打好了基础。
3.3 void* 指针
在指针类型中有一种特殊的类型是 void * 类型的,可以理解为无具体类型的指针(或者叫泛型指针),这种类型的指针可以用来接受任意类型地址。但是也有局限性, void* 类型的指针不能直接进行指针的+-整数和解引用的运算。
举例:
课件代码 11-017 · PDF 第 11 页
#include <stdio.h>
int main(){ int a = 10; int* pa = &a; char* pc = &a; return 0;}在上面的代码中,将一个 int 类型的变量的地址赋值给一个 char* 类型的指针变量。编译器给出了一个警告(如下图),是因为类型不兼容。而使用 void* 类型就不会有这样的问题。

VS2022编译的结果使用 void* 类型的指针接收地址:
课件代码 11-018 · PDF 第 12 页
#include <stdio.h>
int main(){ int a = 10; void* pa = &a; void* pc = &a;
*pa = 10; *pc = 0; return 0;}原例说明: 这是 void 指针运算/解引用的错误辨析;标准 C 不能直接解引用 void 指针参与普通数值操作,应先确定实际对象类型。
VS编译代码的结果:

VS2022编译的结果这里可见, void* 类型的指针可以接收不同类型的地址,但是无法直接进行指针运算。
那么 void* 类型的指针到底有什么用呢?
一般 void* 类型的指针是使用在函数参数的部分,用来接收不同类型数据的地址,这样的设计可以实现泛型编程的效果。使得一个函数来处理多种类型的数据,在后期的课程中我们会再次讲解。
4. 指针运算
指针的基本运算有三种,分别是:
-
指针+- 整数
-
指针-指针
-
指针的关系运算
4.1 指针+- 整数
4.1.1 指针访问一维数组
因为数组在内存中是连续存放的,只要知道第一个元素的地址,顺藤摸瓜就能找到后面的所有元素。
课件代码 11-019 · PDF 第 13 页
int arr[10] = {1,2,3,4,5,6,7,8,9,10};课件代码 11-020 · PDF 第 13,14 页
#include <stdio.h>int main(){ int arr[10] = {1,2,3,4,5,6,7,8,9,10}; int *p = &arr[0]; //获得第一个元素的地址 int i = 0; int sz = sizeof(arr)/sizeof(arr[0]); for(i = 0; i < sz; i++) { printf("%d ", *(p + i));//p+i是下标为i这个元素的地址 } return 0;}上面的代码是 i 作为偏移量在不断变化,使得 p+i 这个地址在变化;这个代码也可以换一种写法:
课件代码 11-021 · PDF 第 14 页
#include <stdio.h>int main(){ int arr[10] = {1,2,3,4,5,6,7,8,9,10}; int *p = &arr[0]; //获得第一个元素的地址 int i = 0; int sz = sizeof(arr)/sizeof(arr[0]); for(i = 0; i < sz; i++) { printf("%d ", *p); p++;//p = p+1 } return 0;}这种写法中,如果循环次数控制的有问题,使得p不断地往后偏移,最后超出数组本身的内存区域的话,这时的指针就越界了,指针越界后还是继续使用也会非法访问内存。
4.1.2 模拟实现strlen(1)
课件代码 11-022 · PDF 第 14,15 页
#include <stdio.h>//计数器的方法size_t my_strlen(char *str){ size_t count = 0; while(*str != '\0') { count++; str++; } return count;}
int main(){ printf("%zu\n", my_strlen("abcdef")); //这样传参的时候,是把字符串首字符的地址传 给my_strlen return 0;}4.2 指针 - 指针
4.2.1 为什么会有指针-指针
日期1 + 天数 = 日期2日期2 + 天数 = 日期1日期2 - 日期1 = 天数和日期运算的道理一样,指针也可以进行类似的运算
-
指针1 + 整数n = 指针2 (向后跳过n个元素后的地址)
-
指针2 - 整数n = 指针1 (向前跳过n个元素后的地址)
-
指针2 - 指针1 = 整数n (指针1 - 指针2 = -n)
指针 - 指针 结果的绝对值是两个指针之间元素的个数。
两个指针相减运算的前提是两个指针指向同一块内存空间,否则计算没有意义。
课件代码 11-023 · PDF 第 15 页
#include <stdio.h>int main(){ int arr[10] = {1, 2,3,4,5,6,7,8,9,10}; printf("%d\n", &arr[9] - &arr[0]);
return 0;}4.2.2 模拟实现strlen(2)
课件代码 11-024 · PDF 第 16,17 页
//指针-指针#include <stdio.h>size_t my_strlen(char *str){ char *end = str; while(*end != '\0') //向后寻找\0 end++; return end - str;}
int main(){ printf("%zu\n", my_strlen("abcdef")); return 0;}4.3 指针的关系运算
地址的本质还是数值,数值是可以比较大小的,所以也就满足关系运算。
这次我们重新改造一下前面写过的指针访问一维数组的代码,因为数组的元素的地址随着下标的增长在不断地变大的,所以 &arr[0] < &arr[sz] 的,所以可以使用指针的关系运算来换一种方式来实现。
课件代码 11-025 · PDF 第 17 页
//指针的关系运算#include <stdio.h>
int main(){ int arr[10] = {1,2,3,4,5,6,7,8,9,10}; int *p = &arr[0]; int sz = sizeof(arr)/sizeof(arr[0]); while(p < &arr[sz]) //指针的大小比较 { printf("%d ", *p); p++; } return 0;}5. 传值调用和传址调用
学习指针的目的是使用指针解决问题,那什么问题,非指针不可呢?
例如:写一个函数,交换两个整型变量的值一番思考后,我们可能写出这样的代码:
课件代码 11-026 · PDF 第 18 页
#include <stdio.h>
void Swap1(int x, int y){ int tmp = x; x = y; y = tmp;}
int main(){ int a = 0; int b = 0; scanf("%d %d", &a, &b); printf("交换前:a=%d b=%d\n", a, b); Swap1(a, b); printf("交换后:a=%d b=%d\n", a, b); return 0;}当我们运行代码,结果如下:

我们发现其实没产生交换的效果,这是为什么呢?
调试一下,试试呢?

我们发现在main函数内部,创建了a和b,a的地址是0x00cffdd0,b的地址是0x00cffdc4,在调用Swap1函数时,将a和b传递给了Swap1函数,在Swap1函数内部创建了形参x和y接收a和b的值,但是x的地址是0x00cffcec,y的地址是0x00cffcf0,x和y确实接收到了a和b的值,不过x的地址和a的地址不一样,y的地址和b的地址不一样,相当于x和y是独立的空间,那么在Swap1函数内部交换x和y的值,自然不会影响a和b,当Swap1函数调用结束后回到main函数,a和b的没法交换。
Swap1函数在使用的时候,是把变量本身直接传递给了函数,这种调用函数的方式叫传值调用。我们在学习函数时编写的函数基本都是传值调用。
结论:传值调用时,实参传递给形参的时候,形参会单独创建一份临时空间来接收实参,对形参的修改不影响实参。所以Swap1是失败的了。
那怎么办呢?
我们现在要解决的就是当调用Swap函数的时候,Swap函数内部操作的就是main函数中的a和b,直接将a和b的值交换了。那么就可以使用指针了,在main函数中将a和b的地址传递给Swap函数,Swap函数里边通过地址间接的操作main函数中的a和b,并达到交换的效果就好了。
课件代码 11-027 · PDF 第 19,20 页
#include <stdio.h>
void Swap2(int*p1, int*p2){ int tmp = 0; tmp = *p1; // tmp = a; *p1 = *p2; // a = b; *p2 = tmp; // b = tmp}
int main(){ int a = 0; int b = 0; scanf("%d %d", &a, &b); printf("交换前:a=%d b=%d\n", a, b); Swap2(&a, &b); printf("交换后:a=%d b=%d\n", a, b);
return 0;}首先看输出结果:

可见实现成Swap2的方式,顺利完成了任务,这里调用Swap2函数的时候是将变量的地址传递给了函数,这种函数调用方式叫:传址调用。
🎈 传址调用,可以让函数和主调函数之间建立真正的联系,在函数内部可以修改主调函数中的
变量;所以未来函数中只是需要主调函数中的变量值来实现计算,就可以采用传值调用。
如果函数内部要修改主调函数中的变量的值,就需要传址调用。
6. 二级指针
指针变量也是变量,是变量就有地址,那指针变量的地址存放在哪里?
这就是 二级指针 。
课件代码 11-028 · PDF 第 20,21 页
#include <stdio.h>int main(){ int a = 10; int *pa = &a; int** ppa = &pa; //ppa就是二级指 针变量
return 0;}对于二级指针的运算有:
- *ppa 通过对ppa中的地址进行解引用,这样找到的是 pa , *ppa 其实访问的就是 pa .
课件代码 11-029 · PDF 第 21 页
int b = 20;*ppa = &b;//等价于 pa = &b;- **ppa 先通过 *ppa 找到 pa ,然后对 pa 进行解引用操作: *pa ,那找到的是 a .
课件代码 11-030 · PDF 第 21 页
**ppa = 30;//等价于*pa = 30;//等价于a = 30;二级指针变量取出地址要储存起来,也需要一个变量,这个时候就有了三级指针,当然理论上四级指针也是存在的,依次类推。
课件中的参考链接
支持与分享
如果这篇文章对你有帮助,欢迎分享给更多人或打赏支持!













