Lesson 0007B · 指针与内存模型

① 程序设计基础 — 指针进阶课

1. 先记住：内存分四区

你写的 C++ 程序运行时，操作系统给了它一块内存。习惯上分成四块：

你之前写的 int a = 10; 大多数情况在栈上；写 int* p = new int; 时，p 这个指针本身在栈上，*p 那块内容在堆上。

2. 栈：进函数就有，出函数就没了

void f() {
    int x = 10;          // x 在栈上
}                        // 函数结束，x 自动消失

int main() {
    f();
    // 这里已经没有 x 了，别想再用 x
    return 0;
}

栈的好处：不用管清理，系统自动回收。坏处：生命周期太短，函数一返回就没了。

int* bad() {
    int x = 10;
    return &x;           // x 在栈上，函数返回后 x 就死了
}                        // 返回的地址指向已死的内存 → 悬空指针

int main() {
    int* p = bad();
    cout << *p;         // 未定义行为：可能碰巧对，可能乱码，可能崩
}

结论：局部变量的地址不要 return 出去。想让数据活得比函数久，就要用堆。

3. 堆：你 new，你就要 delete

int* good() {
    int* p = new int(10);   // 在堆上创建 int，初值 10
    return p;               // 返回堆地址：合法！因为堆内存还活着
}

int main() {
    int* p = good();
    cout << *p;            // 10
    delete p;               // 不用了，手动释放
    p = nullptr;            // 释放后清空指针，防止误用
    return 0;
}

堆的好处：生命周期自己控制。坏处：忘了 delete 就会内存泄漏 —— 程序一直占着那块内存不还。

4. 动态数组：new[] 配 delete[]

int n;
cin >> n;

int* arr = new int[n];       // 大小运行时才定，所以叫“动态”
for (int i = 0; i < n; i++) {
    arr[i] = i * i;
}

for (int i = 0; i < n; i++) {
    cout << arr[i] << " ";
}

delete[] arr;                // 数组必须用 delete[]，不能写 delete
arr = nullptr;

5. 悬空指针：delete 后别再用

int* p = new int(5);
delete p;        // 内存还回去了
// 但 p 仍然保存着原来的地址

cout << *p;     // 悬空指针：访问已释放的内存，危险！
p = nullptr;     // 正确做法：立刻把 p 清空

把指针想象成“门禁卡”：delete 之后卡作废了，但你还攥着；再刷就可能出问题。最稳妥的是作废后直接扔掉 —— 赋成 nullptr。

6. 指针为什么 +1 不是地址 +1

int arr[] = {10, 20, 30};
int* p = arr;         // p 指向 arr[0]

cout << *p;           // 10
p++;                  // 不是地址加 1 字节，而是跳到下一个 int
cout << *p;           // 20

指针 +1 会自动跳过“一个元素的大小”。int* 就跳 4 字节，double* 就跳 8 字节。这正是 arr[i] 和 *(arr + i) 等价的原因。

7. 什么时候用指针，什么时候用引用

8. 坑点清单

• 返回局部变量的地址：栈上的变量在函数返回时就没了，返回它的地址等于交出一张已作废的门禁卡。
• delete 之后指针还留着旧地址：再解引用是未定义行为。释放完立刻 p = nullptr;。
• new[] 只能配 delete[]：写成 delete arr 或者 free(arr) 都不对。
• 忘了 delete 就是内存泄漏：程序不报错、不崩溃，只是悄悄占着内存不还，最难查。
• 栈上的东西不要指望它活过函数：数据要活得久，就 new 到堆上，或者干脆用 vector / string 托管。
• 指针 +1 不是地址加 1：它按指向类型的大小跳，别拿它当字节偏移用。

9. 小测

10. 动手练习

本课小结

• 内存四区：代码区、全局区、栈、堆；只有堆归你手动管。
• 栈：放局部变量和参数，自动清理，但函数一结束就消失。
• 堆：放 new 出来的数据，活得久，但要你 delete。
• 别返回局部变量地址；要长期保存就用 new 返回堆上的地址。
• new[] 配 delete[]；delete 之后立刻 p = nullptr。
• 指针 +1 按元素大小移动，所以 arr[i] 就是 *(arr + i)。