深色模式
第 17 章:内存与指针
本章承接第 1 章的变量与第 10 章的数组:第 1 章说每个变量有自己的类型、占自己的空间,本章掀开盖子看这个"空间"到底在哪。第 4 章讲了源代码怎么被编译成机器码,本章讲程序运行时数据放在哪里——两章一前一后,是理解"编译型 vs 解释型"的两根支柱,第 0 章埋下的伏笔到本章收掉。
本章能学到什么
- 内存是一排带编号的格子,编号就是地址
- 每种变量占几个格子:
sizeof实测 - 指针是"存地址的变量",
&取地址,*取内容 - 指针和数组的关系,
new/delete动态分配 - 悬垂指针和内存泄漏这两个著名的坑
场景:游戏角色的血量存在哪
cpp
int hp = 100;这行代码跑了千百遍。但 hp 这个变量究竟待在计算机的什么地方?被打了一拳,hp -= 20 改的又是哪里?屏幕上的角色挨打的动画只是表演,真正发生的变化,是内存里某几个格子里的数字从 100 变成了 80。
答案:内存。程序运行时,每个变量都在内存里占一块地方。第 8 章还有一个一直没解释的疑点:为什么值传递的函数改不动外面的变量,传引用(int&)就改得动?答案也藏在内存里。本章把这件事看到底——不光看变量住在哪,还要学会用一个叫"指针"的工具,直接说出这个"哪"。
内存:一排带编号的格子
把内存想象成教学楼的储物柜:一排一模一样的格子,每个格子 1 字节(byte),每个格子有一个编号。这个编号叫地址。
| 类比 | 内存里的对应 |
|---|---|
| 储物柜格子 | 1 字节 |
| 格子编号 | 地址 |
| 柜子里的东西 | 数据 |
| 柜子上贴的名字条 | 变量名 |
变量名只是贴在格子上的名字条,方便人记;计算机真正用的是地址。地址通常写成十六进制,长得像 0x16f1b2a98。
一个 int 要占 4 个连在一起的格子,就像一个大书包占了四个柜子。
看一眼内存:一张地图
把 int hp = 100; 画成地图,是这样的:
text
地址 内容
0x16f1b2a98 ← hp 占的 4 个格子,装着 100
0x16f1b2a99
0x16f1b2a9a
0x16f1b2a9b一个 int 占连续 4 格,变量名 hp 是贴在这 4 格上的名字条。&hp 得到的是第一格的编号 0x16f1b2a98。指针 p 自己也是变量,也占格子(64 位机上 8 格),它的"内容"就是 hp 的地址——纸条也要占地方。
text
hp 的格子:装着 100
p 的格子:装着 0x16f1b2a98 ← hp 的地址两层关系一目了然:p 装的是"去哪找",hp 装的是"是什么"。
sizeof:每种变量占几个格子
sizeof 可以量出每种类型占多少字节:
cpp
#include <iostream>
using namespace std;
int main() {
cout << "char " << sizeof(char) << endl;
cout << "bool " << sizeof(bool) << endl;
cout << "int " << sizeof(int) << endl;
cout << "long long " << sizeof(long long) << endl;
cout << "double " << sizeof(double) << endl;
cout << "int* " << sizeof(int*) << endl; // 指针本身占多少
return 0;
}在 64 位电脑上的典型结果:
text
char 1
bool 1
int 4
long long 8
double 8
int* 8| 类型 | 字节数 | 能装什么 |
|---|---|---|
char | 1 | 一个字母 |
bool | 1 | 真或假 |
int | 4 | 大约正负 21 亿 |
long long | 8 | 更大的整数 |
double | 8 | 带小数的数 |
| 指针 | 8(64 位机) | 一个地址 |
这就是第 1 章那张"数据类型表"背后的实物:类型不同,占的格子数不同。
指针:存地址的变量
指针是一种变量,里面装的不是数,是另一个变量的地址。
| 写法 | 读法 | 意思 |
|---|---|---|
int* p | p 是指向 int 的指针 | p 里能装一个 int 的地址 |
&hp | 取 hp 的地址 | 看 hp 住在几号格子 |
*p | 取 p 指向的内容 | 按 p 记的地址找上门,看里面装了什么 |
cpp
#include <iostream>
using namespace std;
int main() {
int hp = 100;
int* p = &hp; // p 存的是 hp 的地址
cout << "hp 的值: " << hp << endl;
cout << "hp 的地址: " << &hp << endl;
cout << "p 存的地址: " << p << endl;
cout << "*p 取内容: " << *p << endl;
*p = 80; // 通过指针改 hp
cout << "改后 hp: " << hp << endl;
return 0;
}text
hp 的值: 100
hp 的地址: 0x16f1b2a98
p 存的地址: 0x16f1b2a98
*p 取内容: 100
改后 hp: 80地址那两行每次运行的数字都不一样——变量这次分到哪个格子是操作系统安排的,属于正常现象。
用快递打比方:hp 是收件人,地址是门牌号,p 是记着门牌号的纸条,*p = 80 是"按纸条上的地址上门,把东西换成 80"。所以改的是 hp 本人。第 8 章的引用传递也是同一个道理:把地址递进了函数,函数就摸到了变量本人。
指针与数组:为什么是同一家人
第 10 章学过数组。现在揭晓一个秘密:数组名几乎就是第一个元素的地址。
cpp
#include <iostream>
using namespace std;
int main() {
int arr[3] = {10, 20, 30};
cout << *arr << endl; // 10:arr 指向第一个元素
cout << *(arr + 1) << endl; // 20:往后数 1 个元素,等价于 arr[1]
cout << *(arr + 2) << endl; // 30:等价于 arr[2]
return 0;
}text
10
20
30arr[i] 和 *(arr + i) 是同一件事的两种写法。数组下标从 0 开始的原因也藏在这里:0 的意思是"从开头那个元素往后数 0 步"。数组元素在内存里是紧挨着排的,所以"往后数 i 步"正好落到第 i 个元素上。
注意 arr + 1 不是地址数字加 1,而是"往后挪一个 int"——编译器知道一个 int 占 4 个格子,自动跳 4 格。这就是指针要带类型的原因:int* 知道每次跳 4 格,double* 知道每次跳 8 格。
new 与 delete:动态分配
普通变量的格子是编译时就定好的,程序一结束自动收回,这块区域叫"栈"。有时程序跑起来才知道要多少空间——比如玩家数量不固定,这时要向另一块更大的区域"堆"临时申请:用 new 申请,用完用 delete 归还。
| 区域 | 谁管 | 什么时候收回 |
|---|---|---|
| 栈(普通变量) | 编译器自动管 | 变量离开作用域就收回 |
堆(new 出来的) | 程序员管 | 只有 delete 才收回 |
cpp
#include <iostream>
using namespace std;
int main() {
int* p = new int; // 在堆上申请一个 int 的格子
*p = 42;
cout << *p << endl; // 42
delete p; // 用完归还,格子被系统收回
p = nullptr; // 纸条清空,防止误用
return 0;
}text
42规矩很简单:new 和 delete 必须成对出现,借了要还。
第 10 章的 vector 为什么不用操心这些?因为 vector 把"申请"和"归还"打包在自己内部:对象出生时自动申请内存,对象消失时自动归还。这个思路叫 RAII(资源获取即初始化)。现代 C++ 优先用 vector、string 这些容器,尽量少的直接写 new——让容器替人管内存。
两个著名的坑
手动管内存,就可能有管错的时候:
| 坑 | 是什么 | 后果 |
|---|---|---|
| 悬垂指针 | delete 之后还在用 p | 读到垃圾值,或程序崩溃 |
| 内存泄漏 | new 了忘记 delete | 程序越跑越占内存,像借了书不还 |
| 野指针 | 指针没初始化就拿来用 | 指向随机地址,后果不可预测 |
| 重复释放 | 同一个地址 delete 两次 | 程序行为无法预料 |
cpp
int* p = new int;
delete p;
cout << *p << endl; // 悬垂指针:格子已经还了,还在上门对付办法都是习惯:delete 后立刻 p = nullptr;写了 new 就马上想好 delete 写在哪;指针声明时就初始化。
指针与引用:第 8 章的老朋友
第 8 章的引用传递(int&)和本章的指针是亲戚——都能让函数摸到外面的变量。区别在写法:
| 对比 | 引用 int& | 指针 int* |
|---|---|---|
| 本质 | 变量的另一个名字 | 存地址的变量 |
| 使用时 | 像普通变量一样用 | 要用 * 取内容 |
| 能不能为空 | 不能,必须指着某个变量 | 能,nullptr 表示空 |
| 适合 | 函数参数 | 动态分配、数组遍历 |
日常写函数参数,引用更顺手;需要 new/delete、需要"可能没有"的地方,才轮到指针。
数组作参数:其实在传地址
第 8 章还留过一个疑点:普通变量传参是复制,改不动外面;数组传进函数却改得动。现在可以解释了:
cpp
#include <iostream>
using namespace std;
void doubleAll(int arr[], int n) { // 收到的其实是第一个元素的地址
for (int i = 0; i < n; i++) {
arr[i] *= 2; // 直接改外面的数组
}
}
int main() {
int nums[3] = {1, 2, 3};
doubleAll(nums, 3);
cout << nums[0] << " " << nums[1] << " " << nums[2] << endl;
return 0;
}text
2 4 6数组名递过去的是地址,函数里的 arr[i] 就是 *(arr + i),改的是同一排格子。也正因为传过去的只是地址,函数不知道这排格子有多长,所以要额外传一个长度 n——这是数组传参的固定搭档。
【跨语言对照】内存管理与两种执行方式
本质问题:数据用完了,占的内存格子谁来收?程序又是怎么从源代码变成 CPU 能执行的动作的?
各自做法:
| 问题 | C++ | Python |
|---|---|---|
| 内存谁申请 | 程序员:new,或容器代劳 | 解释器自动申请 |
| 内存谁回收 | 程序员:delete,或 RAII 自动归还 | 垃圾回收器自动收走 |
| 变量是什么 | 一块有地址的内存格子 | 贴在对象上的一张标签 |
| 能不能看地址 | 能,& 直接看、直接用 | 能用 id() 看,但不能拿地址操作 |
| 源代码怎么跑起来 | 先编译成机器码,再直接执行 | 解释器逐行翻译、逐行执行 |
姊妹篇——《Python 从入门到精通》第 17 章讲的是 Python 侧的同一个主题:数据在内存里到底怎么放。那边的变量不是格子,而是"贴在盒子上的标签"。
为什么设计不一样:这就回到第 0 章埋的伏笔了。C++ 是编译型语言:编译器把源代码整个翻译成机器码(第 4 章见过这道工序),程序运行时直接操作内存——所以快,所以能看地址,所以内存责任也在程序员肩上。Python 是解释型语言:解释器陪在程序旁边,逐行翻译、逐行执行,顺手把申请内存、回收内存这些杂事全包了——所以省心,所以变量只是标签,所以地址看得见摸不着。
两种方式没有谁替代谁:游戏引擎、操作系统用前者,数据分析、人工智能用后者。学到这里,第 1 章的"类型"和第 4 章的"编译"再加上本章的"内存"合起来,"编译型 vs 解释型"这句话就不再是名词,而是亲眼见过的两种世界。
小结
内存是一排带编号的格子,编号叫地址;类型决定一个变量占几格;指针是存地址的变量,& 取地址、* 取内容;数组名约等于第一个元素的地址;new/delete 向堆借还格子,vector 这类容器用 RAII 替人管好这一切。指针是 C++ 给程序员的一把钥匙——能开门,也能撬错门,坑表里那四条就是撬错门的后果。下一章第 18 章会见到更多现成的标准库工具,它们大多数都在内部悄悄用着本章的机制。
动手实验
- 定义两个紧挨着的
int变量a和b,打印它们的地址和sizeof(int),看看两个地址差几。 - 写一个函数
swap(int* a, int* b),通过指针交换两个变量的值,在main里验证。 - 用
new int[5]动态申请一个数组,填入 1~5,打印出来,最后用delete[]归还(数组的归还要带[])。
💡 查看答案
第 1 题:
cpp
int a = 1;
int b = 2;
cout << &a << endl; // 例如 0x16f1b2a98
cout << &b << endl; // 例如 0x16f1b2a94
cout << sizeof(int) << endl; // 4两个地址通常正好差 4——一个 int 占 4 个格子,两个紧挨着的变量地址就相差 4(有的机器上排列顺序相反,差值的绝对值是 4 即可)。
💡 查看答案
第 2 题:
cpp
#include <iostream>
using namespace std;
void swap(int* a, int* b) { // 收到两张记着地址的纸条
int temp = *a; // 按纸条上门取值
*a = *b;
*b = temp;
}
int main() {
int x = 10, y = 20;
swap(&x, &y); // 把 x 和 y 的地址递过去
cout << x << " " << y << endl;
return 0;
}text
20 10第 8 章讲过:值传递改不动外面的变量。传地址就改得动,因为指针让函数摸到了变量本人。
💡 查看答案
第 3 题:
cpp
#include <iostream>
using namespace std;
int main() {
int* arr = new int[5]; // 申请连续 5 个 int
for (int i = 0; i < 5; i++) {
arr[i] = i + 1;
cout << arr[i] << " ";
}
cout << endl;
delete[] arr; // 数组要用 delete[]
arr = nullptr;
return 0;
}text
1 2 3 4 5new 配 delete,new[] 配 delete[],借什么还什么。
