如何修复内存访问越界（Out of Bound Memory Access）？还有哪些规避方法？

问题背景 #

需要修复**内存越界访问（访问超出内存块上限）**问题，存在问题的代码如下：

int main()
{
    int n = 3;
    int a[n] = {1,2,3};

    ...
    // 代码执行过程中n可能被增大10，直接访问a[n-1]会触发内存越界
    ...

    cout<<a[n-1];
    return 0;
}

代码初始时n=3，定义了变长数组a[n]，但执行过程中n的值可能被增加10，导致访问a[n-1]时出现内存越界。

当前修复方案 #

已通过添加条件检查规避问题，修正后代码如下：

int main()
{
    int n = 3;
    int a[n] = {1,2,3};
    ...

    // 代码执行过程中n可能被增大10，直接访问a[n-1]会触发内存越界
    ...
    if(n<= 3)
    {
         cout<<a[n-1];    
    }
    return 0;
}

其他可行的解决方法 #

除了基于大小的if检查，还有以下几种更可靠的方式避免内存越界：

1. 使用C++标准容器（推荐） #

用std::vector替代变长数组，它会自动管理内存、支持动态扩容，还提供at()方法做边界检查（越界时抛出std::out_of_range异常）：

#include <vector>
#include <iostream>

int main()
{
    std::vector<int> a = {1,2,3};
    int n = 3;

    ...
    // 如果需要扩容，可直接用push_back或resize匹配新的n
    // a.resize(n);
    ...

    try {
        cout << a.at(n-1); // 自动做边界检查，越界抛异常
    } catch (const std::out_of_range& e) {
        cout << "访问越界：" << e.what() << endl;
    }
    return 0;
}

如果不需要异常处理，也可以先判断n-1是否小于a.size()，再用[]访问。

2. 动态分配内存 #

用new/delete手动管理数组，同时跟踪数组的实际容量，避免越界：

int main()
{
    int initial_capacity = 3;
    int* a = new int[initial_capacity] {1,2,3};
    int n = initial_capacity;

    ...
    // 若n超过初始容量，重新分配内存并拷贝原有数据
    if (n > initial_capacity) {
        int* temp = new int[n];
        for (int i=0; i<initial_capacity; i++) {
            temp[i] = a[i];
        }
        delete[] a;
        a = temp;
        initial_capacity = n;
    }
    ...

    // 访问前检查边界
    if (n-1 < initial_capacity) {
        cout << a[n-1];
    }
    delete[] a; // 记得手动释放内存
    return 0;
}

这种方式需要手动管理内存，容易出现漏释放问题，不如std::vector省心。

3. 使用带边界检查的数组包装类 #

比如用gsl::span（C++20及以后支持，属于Guidelines Support Library），它能安全引用数组并提供边界检查：

#include <gsl/span>
#include <iostream>

int main()
{
    int n = 3;
    int a[n] = {1,2,3};
    gsl::span<int> safe_a(a, n); // 绑定数组和实际长度

    ...
    // 注意：原数组内存不会自动扩容，若n超过初始3，仍需重新分配数组
    ...

    if (n-1 < safe_a.size()) {
        cout << safe_a[n-1];
    }
    return 0;
}

4. 重构逻辑，拆分变量职责 #

把数组的实际容量和业务逻辑中的计数拆成两个独立变量，避免混淆导致越界：

int main()
{
    const int array_capacity = 3;
    int a[array_capacity] = {1,2,3};
    int business_n = array_capacity;

    ...
    // 业务逻辑中修改business_n，但数组实际容量始终是array_capacity
    ...

    if (business_n-1 < array_capacity) {
        cout << a[business_n-1];
    }
    return 0;
}

内容的提问来源于stack exchange，提问作者sur