视频加载失败

C语言初阶 11:地址、指针类型与指针运算

5750 字
29 分钟
C语言初阶 11:地址、指针类型与指针运算

代码块包含可运行实现、局部片段、输出、故意出错的示例与思考题;它们是独立示例,请结合上下文阅读,不能将整章拼成一个程序。

阅读前先核对#

  • 指针大小由实现/ABI 决定,不能把所有指针在所有环境中统一规定为 4 或 8 字节。打印对象地址用 %p 并转换为 void *。
  • 指针加减和大小比较有数组范围限制,尾后指针可形成但不能解引用;void * 在标准 C 中不能直接做算术或解引用。

本章目标#

  1. 理解指针的本质就是地址

  2. 理解指针类型的意义,能够使用正确的指针类型

  3. 指针的运算的本质就是地址的偏移

  4. 掌握传值调用和传址调用的区别

  5. 掌握二级指针

  6. 为后续指针进阶打好基础

1. 内存和地址#

学习指针必须先理解内存和地址。

在讲解之前,先看一个生活中的案例:

假设有一栋宿舍楼,把你放在楼里,楼上有100个房间,但是房间没有编号,你的一个朋友来找你玩,如果想找到你,就得挨个房子去找,这样效率很低,但是我们如果根据楼层和楼层的房间的情况,给每个房间编上号,如:

课件代码 11-001 · PDF 第 1 页

一楼:101,102,103...
二楼:201,202,203...
...

有了房间号,如果你的朋友得到房间号,就可以快速的找房间,找到你。

第11章第1页配图
第11章第1页配图

第11章第1页配图
第11章第1页配图

生活中,每个房间有了房间号,就能提高效率,能快速地找到房间。

如果把上面的例子对照到计算机中,又是怎么样呢?

计算机上CPU(中央处理器)在处理数据的时候,需要的数据是在内存中读取的,处理后的数据也会放回内存中。

常见的一台电脑上内存是 8GB/16GB/32GB 等,那这些内存空间如何高效的管理呢?

解决办法和上面的例子相似,把内存划分为一个个的内存单元,每个内存单元的大小取1个字节,然后给每一个内存单元一个编号,就类似于房间编号。

第11章第2页配图
第11章第2页配图

计算机中常见的单位介绍:

一个比特位可以存储一个2进制的位1或者0代码块 代码块

课件代码 11-002 · PDF 第 2,3 页

bit - 比特位
Byte - 字节
KB
MB
GB
TB
PB

课件代码 11-003 · PDF 第 2,3 页

1Byte = 8bit
1KB = 1024Byte
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB
1PB = 1024TB
...

第11章第3页配图
第11章第3页配图

其中,每个内存单元,相当于一个学生宿舍,一个字节空间里面能放8个比特位,就好比同学们住的八人间,每个人是一个比特位。

每个内存单元也都有一个编号(这个编号就相当于宿舍房间的门牌号),有了这个内存单元的编号,CPU就可以快速找到一个内存空间。

生活中我们把门牌号也叫地址,在计算机中我们把内存单元的编号也称为地址。C语言中给地址起了新的名字叫:指针。

所以我们可以理解为:

内存单元的编号 == 地址 == 指针

🎈 注意上面我们是为了方便讲解,对真实的内存访问进行了简化的,实际上我们编写的运行在

X86架构的计算机上的C语言程序,是不会直接访问物理内存的。

程序运行时为变量分配的地址,在程序调试过程中,我们看到的地址都是虚拟地址;虚拟地址不是物理地址。虚拟地址是虚拟地址空间中的地址。

虚拟地址空间可以看作操作系统为每个程序提供的一个“假想的、独占的、连续的内存空间”。

程序中的虚拟地址,会由CPU的内存管理单元(MMU)映射到物理内存中,其实程序最终还是会访问物理内存的。这个由虚拟地址换成物理地址的过程,暂时我们不需要关心,学习到操作系统的知识,慢慢再理解就可以了。

第11章第4页配图
第11章第4页配图

我们在学习编程语言的时候,都是在使用虚拟地址的。

🎈 是否存在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;
}

第11章第5页配图
第11章第5页配图

第11章第5页配图
第11章第5页配图

比如,上述的代码就是创建了整型变量a,内存中申请4个字节,用于存放整数10,其中每个字节都有地址,上图中4个字节的地址分别是:

课件代码 11-005 · PDF 第 5 页

0x006FFD70
0x006FFD71
0x006FFD72
0x006FFD73

那我们如何能得到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 类型的对象。

第11章第7页配图
第11章第7页配图

那如果有一个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;
}

第11章第9页配图
第11章第9页配图

第11章第9页配图
第11章第9页配图

X86环境输出结果 X64环境输出结果其实指针变量的大小是取决于数据模型的,下面列出了常见的4个数据模型:

数据模型指的是在特定操作系统、CPU 架构和 ABI(应用程序二进制接口)下,C/C++ 等语言中基本整数类型( short 、 int 、 long 、 long long )以及指针类型的具体位宽(字节数) 的约定。

第11章第9页图表
第11章第9页图表

结论:

  • 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;
}

代码运行的结果如下:

第11章第11页配图
第11章第11页配图

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* 类型就不会有这样的问题。

第11章第12页配图
第11章第12页配图

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编译代码的结果:

第11章第12页配图
第11章第12页配图

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;
}

当我们运行代码,结果如下:

第11章第18页配图
第11章第18页配图

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

调试一下,试试呢?

第11章第19页配图
第11章第19页配图

我们发现在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;
}

首先看输出结果:

第11章第20页配图
第11章第20页配图

可见实现成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;

二级指针变量取出地址要储存起来,也需要一个变量,这个时候就有了三级指针,当然理论上四级指针也是存在的,依次类推。

课件中的参考链接#

支持与分享

如果这篇文章对你有帮助,欢迎分享给更多人或打赏支持!

打赏
C语言初阶 11:地址、指针类型与指针运算
https://16888000.xyz/posts/c-beginner-11-pointers/
作者
小螺号
发布于
2026-11-14
许可协议
CC BY-NC-SA 4.0
Profile Image of the Author
小螺号
Hello, I'm LittleTrumpet.
公告
欢迎来到我的博客!这是一则示例公告。
分类
标签
最新动态
站点统计
文章
26
分类
4
标签
34
总字数
100,664
运行时长
0 天
最后活动
0 天前
站点信息
构建平台
Cloudflare Workers
博客版本
Firefly v6.16.8
文章许可
CC BY-NC-SA 4.0
文章目录