C++中获取触发std::out_of_range的数组及捕获块访问异常容器的可行性

好的，我来一步步解答你的两个问题：

首先要明确：C++原生数组本身不会抛出std::out_of_range异常（因为原生数组的[]操作符没有边界检查），但标准库容器（比如std::vector、std::string、std::array）的at()成员函数会在访问超出有效索引范围时抛出这个异常。

举个简单的例子，用std::vector触发异常：

#include <vector>
#include <stdexcept>
#include <iostream>

int main() {
    std::vector<int> my_vec = {10, 20, 30};
    try {
        // 尝试访问索引3，而my_vec的有效索引是0-2，会触发std::out_of_range
        int value = my_vec.at(3);
    } catch (const std::out_of_range& e) {
        std::cout << "触发异常: " << e.what() << std::endl;
    }
    return 0;
}

类似的，std::string::at()、std::array::at()也会在越界时抛出std::out_of_range。

默认情况下不行——标准库的std::out_of_range异常只包含错误信息（可以通过what()获取），并没有携带任何指向触发它的容器的引用或指针。不过针对你的场景（需要区分两个带lambda的容器，根据触发异常的容器执行不同流程），有两种实用的解决方案：

方案一：自定义异常类，携带容器指针 #

我们可以继承std::out_of_range，扩展出一个能关联到容器的异常类，这样在catch块里就能直接拿到触发异常的容器：

#include <vector>
#include <stdexcept>
#include <string>
#include <iostream>

// 模板化的自定义异常类，支持任意容器类型
template <typename Container>
struct ContainerOutOfRange : public std::out_of_range {
    const Container* source_container; // 指向触发异常的容器

    ContainerOutOfRange(const std::string& msg, const Container* cont)
        : std::out_of_range(msg), source_container(cont) {}
};

// 封装一个安全访问函数，检查越界后抛出自定义异常
template <typename Container>
auto safe_access(const Container& cont, size_t idx) {
    if (idx >= cont.size()) {
        throw ContainerOutOfRange<Container>(
            "容器访问越界", &cont
        );
    }
    return cont.at(idx);
}

int main() {
    // 两个带lambda的容器（这里用vector举例，实际可以是任意带lambda的容器类型）
    std::vector<int> container1 = {1, 2, 3};
    std::vector<int> container2 = {4, 5, 6};

    try {
        safe_access(container1, 3); // 触发container1的异常
        // safe_access(container2, 3); // 如果换成这个，就是container2触发异常
    } catch (const ContainerOutOfRange<std::vector<int>>& e) {
        if (e.source_container == &container1) {
            std::cout << "处理container1触发的异常流程" << std::endl;
        } else if (e.source_container == &container2) {
            std::cout << "处理container2触发的异常流程" << std::endl;
        }
    }
    return 0;
}

这个方案的优点是清晰直接，异常和容器直接绑定，适合复杂场景。

方案二：使用标记变量区分容器 #

如果不想自定义异常，也可以在try块中给每个容器的操作设置标记，catch块通过标记判断是哪个容器触发的异常：

#include <vector>
#include <stdexcept>
#include <iostream>

int main() {
    std::vector<int> container1 = {1, 2, 3};
    std::vector<int> container2 = {4, 5, 6};
    int current_container = 0; // 0: 未操作任何容器，1: container1，2: container2

    try {
        current_container = 1;
        container1.at(3); // 触发异常时，current_container标记为1

        current_container = 2;
        container2.at(3);
    } catch (const std::out_of_range& e) {
        switch(current_container) {
            case 1:
                std::cout << "执行container1对应的异常处理流程" << std::endl;
                break;
            case 2:
                std::cout << "执行container2对应的异常处理流程" << std::endl;
                break;
            default:
                std::cout << "未知容器触发的异常" << std::endl;
        }
    }
    return 0;
}

这个方案更轻量，适合简单场景，但如果容器操作之间有嵌套或依赖，标记变量的维护会比较麻烦。

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