Skip to content

第 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
类型字节数能装什么
char1一个字母
bool1真或假
int4大约正负 21 亿
long long8更大的整数
double8带小数的数
指针8(64 位机)一个地址

这就是第 1 章那张"数据类型表"背后的实物:类型不同,占的格子数不同。

指针:存地址的变量 ​

指针是一种变量,里面装的不是数,是另一个变量的地址。

写法读法意思
int* pp 是指向 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
30

arr[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 章会见到更多现成的标准库工具,它们大多数都在内部悄悄用着本章的机制。

动手实验 ​

  1. 定义两个紧挨着的 int 变量 a 和 b,打印它们的地址和 sizeof(int),看看两个地址差几。
  2. 写一个函数 swap(int* a, int* b),通过指针交换两个变量的值,在 main 里验证。
  3. 用 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 5

new 配 delete,new[] 配 delete[],借什么还什么。