第二节 · 封印符文 · 智能指针

程序运行时，内存被划分为不同的区域，其中最重要的两个是栈和堆。理解它们的区别对于写出高效、安全的代码至关重要。

---

栈内存

栈是自动管理的内存区域。当你声明一个局部变量时，它就在栈上分配。当变量离开作用域时，自动释放。

void foo()
{
    int n = 42;           // 在栈上分配
    string s = "hello";   // 也在栈上
    
    // 函数结束时，n 和 s 自动销毁
}

栈的特点：

• 分配速度快（只需移动栈指针）

• 自动管理，无需手动释放

• 大小有限（通常几 MB）

• 生命周期与作用域绑定

---

堆内存

堆是手动管理的内存区域。使用 new 分配，使用 delete 释放。

int main()
{
    int* p = new int(42);   // 在堆上分配一个 int
    cout << *p << endl;     // 42
    
    delete p;               // 手动释放
    p = nullptr;            // 好习惯：置空
    
    return 0;
}

堆的特点：

• 分配速度较慢

• 需要手动管理（或使用智能指针）

• 大小只受系统内存限制

• 生命周期由程序员控制

---

数组的动态分配

// 动态数组
int* arr = new int[10];

for (int i = 0; i < 10; ++i)
{
    arr[i] = i * i;
}

// 释放数组要用 delete[]
delete[] arr;  // 不是 delete arr!

---

类比：租房与购房

• 栈像住公寓：入住快、退房自动办理，但空间有限

• 堆像买房子：手续复杂、需要自己处理过户，但空间任你选

---

常见错误

// 1. 内存泄漏 - 忘记 delete
void leak()
{
    int* p = new int(42);
    // 忘记 delete p;
}  // p 销毁了，但分配的内存还在！

// 2. 重复释放
int* p = new int(42);
delete p;
delete p;  // 错误！未定义行为

// 3. 使用已释放的内存（悬空指针）
int* p = new int(42);
delete p;
cout << *p << endl;  // 错误！p 指向的内存已释放

// 4. 数组用错了 delete
int* arr = new int[10];
delete arr;    // 错误！应该用 delete[]

---

对象的动态分配

class Person
{
public:
    string name;
    int age;
    
    Person(string n, int a) : name(n), age(a)
    {
        cout << name << " created" << endl;
    }
    
    ~Person()
    {
        cout << name << " destroyed" << endl;
    }
};

int main()
{
    // 栈上创建
    Person p1("Alice", 25);
    
    // 堆上创建
    Person* p2 = new Person("Bob", 30);
    
    delete p2;  // 调用析构函数，释放内存
    
    return 0;
}  // p1 自动销毁

---

返回动态分配的内存

// 不好的做法 - 调用者需要记得 delete
int* createArray(int size)
{
    return new int[size];
}

// 使用
int* arr = createArray(10);
// ... 使用 arr ...
delete[] arr;  // 容易忘记！

// 更好的做法 - 使用容器
vector<int> createVector(int size)
{
    return vector<int>(size);
}

---

堆内存的必要性

什么时候必须用堆？

// 1. 需要控制对象生命周期
class Connection
{
public:
    static Connection* create()
    {
        return new Connection();
    }
    
    void close()
    {
        delete this;  // 对象自己删除自己
    }
};

// 2. 需要大量内存
void processLargeData()
{
    // 栈可能溢出
    // int arr[10000000];  // 危险！
    
    // 用堆更安全
    int* arr = new int[10000000];
    // ...
    delete[] arr;
}

// 3. 运行时才知道大小
void dynamicSize(int n)
{
    int* arr = new int[n];  // n 是运行时确定的
    // ...
    delete[] arr;
}

---

检测内存问题

可以使用工具检测内存泄漏：

• Valgrind（Linux）

• Visual Studio 内存诊断（Windows）

• AddressSanitizer（-fsanitize=address）

---

习题

• 解释为什么返回局部变量的指针是危险的。

• 编写代码演示内存泄漏，然后修复它。

• new 失败时会发生什么？如何处理？