【C++】 动态内存管理

详细探讨 C++ 中的动态内存管理，特别是内存泄漏和内存越界问题，并附上代码示例。

C++ 动态内存管理概述

在 C++ 中，内存主要分为几个区域：

1. 栈 (Stack): 用于存储局部变量、函数参数、函数返回地址等。由编译器自动分配和释放，速度快，但空间有限。变量的生命周期与其作用域绑定。
2. 堆 (Heap): 也称为自由存储区 (Free Store)。用于存储程序运行时动态分配的内存。程序员需要手动请求分配（使用 new）和释放（使用 delete）。空间较大，但分配/释放速度相对较慢，且管理不当容易出错。
3. 全局/静态存储区: 用于存储全局变量和静态变量 (static)。在程序整个运行期间存在。
4. 常量存储区: 存储常量字符串等。

动态内存管理 主要关注堆内存的使用。它允许程序在运行时根据需要申请任意大小的内存块，并在不再需要时将其归还给系统。这对于处理大小在编译时未知的数据（如用户输入、文件内容）或需要长时间存在的数据（生命周期超出单个函数范围）至关重要。

核心操作符:

• new: 在堆上分配内存。
  • new T: 分配足够存储一个 T 类型对象的内存，并返回指向该内存的 T* 指针。如果 T 是类类型，会调用其构造函数。
  • new T[n]: 分配足够存储 n 个 T 类型对象的连续内存（数组），并返回指向第一个元素的 T* 指针。如果 T 是类类型，会调用 n 次默认构造函数。
• delete: 释放由 new 分配的单个对象的内存。
  • delete ptr: 释放 ptr 指向的内存。如果 ptr 指向的是类类型对象，会先调用其析构函数。
• delete[]: 释放由 new[] 分配的数组内存。
  • delete[] ptr: 释放 ptr 指向的数组内存。如果数组元素是类类型，会对数组中的每个元素调用析构函数。

重要规则:

1. new 和 delete 必须配对使用。
2. new[] 和 delete[] 必须配对使用。
3. 绝不能混用：用 delete 释放 new[] 分配的内存，或用 delete[] 释放 new 分配的内存，都会导致未定义行为（通常是崩溃或内存损坏）。
4. 绝不能 delete 同一块内存两次（Double Free）。
5. 绝不能 delete 非 new/new[] 分配的内存（如栈内存地址、全局变量地址）。

内存泄漏 (Memory Leak)

定义: 当程序在堆上分配了内存（使用 new 或 new[]），但在不再需要该内存时，未能通过相应的 delete 或 delete[] 将其释放，导致这块内存无法再被程序访问（指向它的指针丢失），也无法被系统重新分配给其他部分使用。随着时间推移，不断累积的未释放内存会耗尽系统可用内存，可能导致程序性能下降甚至崩溃。

引发原因:

1. 忘记 delete / delete[]: 最常见的原因，分配了内存但在所有执行路径上都没有释放。
2. 指针丢失: 将指向动态分配内存的唯一指针重新赋值给其他地址（或置为 nullptr），导致无法再 delete 原始内存。
3. 异常: 在 new 之后、delete 之前发生异常，如果异常处理不当（没有 catch 块或 catch 块中没有释放逻辑），delete 语句可能被跳过。
4. 循环引用 (主要涉及智能指针): 在使用 std::shared_ptr 时，如果两个对象通过 shared_ptr 相互持有对方，形成循环引用，它们的引用计数永远不会降到 0，导致无法自动释放。

代码示例:

#include <iostream>
#include <vector>

void cause_memory_leak() {
    // 1. 忘记 delete
    int* leaky_int = new int(10);
    std::cout << "Allocated an int: " << *leaky_int << std::endl;
    // 忘记调用 delete leaky_int; 当函数返回时，leaky_int 指针本身被销毁，
    // 但它指向的堆内存没有被释放，造成泄露。

    // 2. 指针丢失
    char* buffer = new char[100];
    std::cout << "Allocated a char buffer." << std::endl;
    buffer[0] = 'a'; // 使用一下

    char* another_buffer = new char[50];
    buffer = another_buffer; // 将 buffer 指向了新的内存块
                              // 原来 buffer 指向的 100 字节内存的地址丢失了
                              // 无法再 delete[] 它，造成泄露。
    std::cout << "Buffer pointer reassigned." << std::endl;

    // 需要释放 another_buffer 指向的内存 (现在 buffer 也指向这里)
    delete[] buffer; // 或者 delete[] another_buffer;
    // 注意：最初分配的100字节已经泄露了！

    // 3. 异常导致泄露 (简化示例)
    try {
        std::vector<int>* data = new std::vector<int>(1000000); // 分配大内存
        std::cout << "Allocated large vector." << std::endl;

        // 模拟在 delete 之前可能发生异常的操作
        if (true) { // 假设这里发生了一个错误条件
           throw std::runtime_error("Something went wrong!");
        }

        // 如果抛出异常，这行代码永远不会执行
        delete data;
        std::cout << "Vector deleted (This won't print if exception occurs)." << std::endl;

    } catch (const std::exception& e) {
        std::cerr << "Caught exception: " << e.what() << std::endl;
        // 异常处理块中没有 delete data; 导致内存泄露
        // 正确做法是在 catch 块中或使用 RAII (如智能指针) 来保证释放
    }
}

int main() {
    std::cout << "--- Demonstrating Memory Leaks ---" << std::endl;
    cause_memory_leak();
    std::cout << "Function cause_memory_leak finished." << std::endl;
    std::cout << "Program continues, but memory might have been leaked." << std::endl;

    // 在实际大型程序中，反复调用类似 cause_memory_leak 的函数会导致内存不断消耗。
    // 可以使用内存检测工具 (如 Valgrind, AddressSanitizer) 来检测泄露。

    return 0;
}

后果:

• 资源耗尽: 可用内存减少，最终可能导致无法再分配新内存，程序或系统崩溃。
• 性能下降: 频繁的内存分配/查找可用块可能变慢，系统内存压力增大也可能导致更频繁的页面交换。
• 程序不稳定: 极端情况下可能导致无法预料的行为。

内存越界 (Memory Out-of-Bounds Access / Buffer Overflow/Underflow)

定义: 当程序试图读取或写入其已分配的内存块边界之外的内存区域时，就会发生内存越界。

• 缓冲区溢出 (Buffer Overflow): 向分配的内存区域（缓冲区）写入的数据超出了其容量，覆盖了相邻的内存区域。
• 缓冲区下溢 (Buffer Underflow): 通常指读取或写入到缓冲区起始地址之前的内存。
• 越界读取 (Out-of-Bounds Read): 读取了不属于当前分配内存块的数据。
• 越界写入 (Out-of-Bounds Write): 写入了不属于当前分配内存块的内存地址（即缓冲区溢出）。

引发原因:

1. 数组索引错误: 使用了小于 0 或大于等于数组大小的索引访问数组元素。
2. 指针算术错误: 对指针进行加减运算后，指向了分配区域之外。
3. 字符串操作不当: 使用不检查边界的 C 风格字符串函数（如 strcpy, strcat, sprintf）时，源字符串长度超过目标缓冲区大小。
4. 类型转换错误: 将指向小内存块的指针强制转换为指向大类型数据的指针，然后解引用，可能访问越界内存。
5. 循环条件错误: 循环变量的终止条件设置不当，导致访问超出数组范围。

代码示例:

#include <iostream>
#include <cstring> // for strcpy

void cause_out_of_bounds() {
    const int SIZE = 5;
    int* arr = new int[SIZE]; // 分配包含 5 个 int 的数组，有效索引为 0, 1, 2, 3, 4

    std::cout << "Allocated array of size " << SIZE << std::endl;

    // 1. 越界写入 (Buffer Overflow)
    std::cout << "\n--- Demonstrating Out-of-Bounds Write ---" << std::endl;
    for (int i = 0; i <= SIZE; ++i) { // 错误：循环条件应为 i < SIZE
        // 当 i = SIZE (即 i = 5) 时，arr[5] 是越界的
        std::cout << "Attempting to write to arr[" << i << "]" << std::endl;
        arr[i] = i * 10; // 当 i = 5 时，写入了不属于 arr 的内存！
                         // 这可能会覆盖 arr 后面的其他数据，或导致崩溃。
        // 现代编译器或运行时检查可能在此处直接崩溃 (如使用 ASan 编译)
    }
    std::cout << "Finished potentially overflowing write loop." << std::endl;

    // 打印看看结果 (如果程序还没崩)
    // 注意：即使写越界了，读可能暂时"正常"，但内存已损坏
    std::cout << "Array contents (might be corrupted or cause crash on access): ";
    for(int i=0; i<SIZE; ++i) { // 这里使用正确边界读取
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;


    // 2. 越界读取
    std::cout << "\n--- Demonstrating Out-of-Bounds Read ---" << std::endl;
    int index_too_large = 10;
    std::cout << "Attempting to read arr[" << index_too_large << "]" << std::endl;
    // 读取远超数组边界的内存，其值是未定义的 (可能是垃圾值，也可能导致崩溃)
    int value = arr[index_too_large];
    std::cout << "Value read from arr[" << index_too_large << "]: " << value << " (Undefined Behavior!)" << std::endl;

    int index_negative = -1;
    std::cout << "Attempting to read arr[" << index_negative << "]" << std::endl;
    // 读取数组之前的内存，同样是未定义行为
    value = arr[index_negative];
    std::cout << "Value read from arr[" << index_negative << "]: " << value << " (Undefined Behavior!)" << std::endl;


    // 3. C 风格字符串溢出
    std::cout << "\n--- Demonstrating C-string Buffer Overflow ---" << std::endl;
    char buffer[10]; // 只能安全存储 9 个字符 + 1 个空终止符 '\0'
    const char* long_string = "This string is definitely too long";

    std::cout << "Buffer size: 10. String to copy length: " << strlen(long_string) << std::endl;
    // strcpy 不检查边界，会一直复制直到遇到源字符串的 '\0'
    // 这将覆盖 buffer 后面的栈内存！非常危险！
    // strcpy(buffer, long_string); // <<<< 潜在的严重错误！取消注释以观察 (可能崩溃)
    std::cout << "strcpy would overflow the buffer!" << std::endl;

    // 更安全的做法是使用 strncpy 或 C++ 的 std::string
    // strncpy(buffer, long_string, sizeof(buffer) - 1);
    // buffer[sizeof(buffer) - 1] = '\0'; // 确保空终止

    // 释放之前分配的数组内存
    delete[] arr;
    std::cout << "\nArray arr deleted." << std::endl;
}

int main() {
    std::cout << "--- Demonstrating Memory Out-of-Bounds ---" << std::endl;
    cause_out_of_bounds();
    std::cout << "Function cause_out_of_bounds finished (if it didn't crash)." << std::endl;
    return 0;
}

后果:

• 数据损坏: 覆盖了相邻变量或重要数据结构（如函数返回地址、虚函数表指针），导致程序逻辑错误。
• 程序崩溃: 访问了无效或受保护的内存地址，操作系统会终止程序（段错误 Segmentation Fault / Access Violation）。
• 安全漏洞: 最严重的后果之一。精心构造的输入可以利用缓冲区溢出，覆盖函数返回地址，使程序跳转到攻击者注入的恶意代码执行，从而获得系统控制权。这是许多安全攻击的基础。
• 未定义行为: 结果不可预测，可能这次运行正常，下次就崩溃，或者在不同环境、不同编译器下表现不同，极难调试。

如何避免内存泄漏和越界？

1. 优先使用 RAII (Resource Acquisition Is Initialization): 这是 C++ 中管理资源（包括内存）的核心思想。

   • 使用智能指针: std::unique_ptr, std::shared_ptr, std::weak_ptr。它们在构造时获取资源（内存），在析构时自动释放资源。这是现代 C++ 中管理动态内存的首选方法，能极大减少内存泄漏。
     • std::unique_ptr: 独占所有权，轻量级，无法复制，只能移动。当 unique_ptr 离开作用域或被重置时，自动 delete (或 delete[]) 它所管理的内存。
     • std::shared_ptr: 共享所有权，使用引用计数。只有当最后一个指向对象的 shared_ptr 被销毁时，内存才会被释放。需要注意循环引用的问题（可用 std::weak_ptr 解决）。
   • 使用标准库容器: 如 std::vector, std::string, std::map 等。它们内部封装了动态内存管理，能自动处理内存的分配、增长和释放，既安全又方便。

2. 坚持配对使用 new/delete 和 new[]/delete[]: 如果必须手动管理内存，务必遵守此规则。

3. 初始化指针: 声明指针时初始化为 nullptr，delete 之后也将其设为 nullptr，可以避免悬垂指针（Dangling Pointer）和重复释放（Double Free）的一些问题。

   int* ptr = nullptr;
   ptr = new int(5);
   // ... use ptr ...
   delete ptr;
   ptr = nullptr; // 好习惯
   

4. 小心指针算术和数组索引: 确保索引总是在 [0, size - 1] 范围内。进行指针运算时要清楚边界。

5. 使用边界检查的函数: 优先使用 std::string 而不是 C 风格字符数组。如果必须用 C 风格字符串，使用 strncpy, snprintf 等有大小限制的版本，并总是确保缓冲区足够大且正确处理空终止符。使用 std::vector 的 at() 方法进行访问（会进行边界检查并抛出异常），而不是 [] 操作符（不检查边界，越界是未定义行为）。

6. 代码审查和测试: 仔细检查内存分配和释放逻辑。使用静态分析工具和动态内存检测工具（如 Valgrind, AddressSanitizer (ASan), MemorySanitizer (MSan)）来帮助发现内存错误。

7. 异常安全: 编写代码时要考虑异常发生的情况。确保即使发生异常，已分配的资源也能被正确释放。RAII 是实现异常安全的关键。

现代 C++ 示例 (使用智能指针避免泄露):

#include <iostream>
#include <memory> // for smart pointers
#include <vector>

void no_leak_with_smart_pointers() {
    // 使用 unique_ptr 管理单个对象
    std::unique_ptr<int> safe_int = std::make_unique<int>(20); // C++14+, 推荐方式
    // 或者: std::unique_ptr<int> safe_int(new int(20)); // C++11
    std::cout << "Allocated int via unique_ptr: " << *safe_int << std::endl;
    // 不需要手动 delete，当 safe_int 离开作用域时，内存会自动释放

    // 使用 unique_ptr 管理动态数组 (注意需要指定数组形式)
    std::unique_ptr<char[]> safe_buffer = std::make_unique<char[]>(100); // C++14+
    // 或者: std::unique_ptr<char[]> safe_buffer(new char[100]); // C++11
    safe_buffer[0] = 'b';
    std::cout << "Allocated char buffer via unique_ptr." << std::endl;
    // 不需要手动 delete[]，离开作用域时自动释放

    // 使用 shared_ptr 管理可能被多处共享的对象
    std::shared_ptr<std::vector<int>> shared_data = std::make_shared<std::vector<int>>(5, 1); // 推荐
    std::cout << "Allocated vector via shared_ptr. Use count: " << shared_data.use_count() << std::endl;
    {
        std::shared_ptr<std::vector<int>> another_ref = shared_data;
        std::cout << "Inside scope, another shared_ptr created. Use count: " << shared_data.use_count() << std::endl;
        // another_ref 离开作用域，引用计数减 1
    }
    std::cout << "Outside scope. Use count: " << shared_data.use_count() << std::endl;
    // 当最后一个 shared_ptr (这里是 shared_data) 离开作用域时，vector 才会被 delete

    // 即使发生异常，智能指针的析构函数也会被调用 (栈展开机制)，保证内存释放
    try {
        std::unique_ptr<double> potentially_leaky = std::make_unique<double>(3.14);
        std::cout << "Allocated double: " << *potentially_leaky << std::endl;
        if (true) {
             throw std::runtime_error("Error after allocation!");
        }
        // delete 不会被调用，但 potentially_leaky 的析构函数会在栈展开时调用，释放内存
    } catch (const std::exception& e) {
        std::cerr << "Caught exception: " << e.what() << std::endl;
        // 内存已经被 unique_ptr 安全释放了
    }

} // 所有在此函数中通过智能指针分配的内存都在这里被自动释放

int main() {
    std::cout << "--- Demonstrating Safe Memory Management with Smart Pointers ---" << std::endl;
    no_leak_with_smart_pointers();
    std::cout << "Function finished, memory managed safely." << std::endl;
    return 0;
}

总结来说，理解 C++ 的内存模型，掌握 new/delete 的基本用法，并深刻认识内存泄漏和内存越界的危害至关重要。在现代 C++ 编程中，应优先采用 RAII 原则，广泛使用智能指针和标准库容器来自动化内存管理，从而编写更安全、更健壮、更易于维护的代码。手动管理内存应仅限于必要情况，并需格外小心。