C++多维std::vector快速获取子向量的方法及通用方案

针对4维vector取最后一维固定索引的高效处理 #

首先明确：嵌套的std::vector本质是多层动态数组，每一层子vector的内存并不保证连续。如果需要生成独立的3维vector副本，三层循环的拷贝操作无法完全避免，但可以通过优化循环顺序提升效率——优先遍历最内层维度，利用CPU缓存局部性减少缓存失效：

// 假设x是vector<vector<vector<vector<int>>>>类型
vector<vector<vector<int>>> y;
y.reserve(x.size());
for (const auto& dim1 : x) {
    vector<vector<int>> y_dim1;
    y_dim1.reserve(dim1.size());
    for (const auto& dim2 : dim1) {
        vector<int> y_dim2;
        y_dim2.reserve(dim2.size());
        // 优先遍历最内层，利用缓存
        for (const auto& dim3 : dim2) {
            y_dim2.push_back(dim3[2]);
        }
        y_dim1.push_back(std::move(y_dim2));
    }
    y.push_back(std::move(y_dim1));
}

如果不需要独立副本，仅需访问数据，可实现轻量包装类作为视图，完全避免拷贝：

template<typename T>
struct FourDToThreeDView {
    const vector<vector<vector<vector<T>>>>& parent;
    size_t fixed_last_idx;

    // 代理类：模拟二维vector的访问
    struct TwoDProxy {
        const vector<vector<vector<T>>>& dim1_data;
        size_t fixed_idx;

        // 代理类：模拟一维vector的访问
        struct OneDProxy {
            const vector<vector<T>>& dim2_data;
            size_t fixed_idx;

            const T& operator[](size_t k) const {
                return dim2_data[k][fixed_idx];
            }
        };

        const OneDProxy operator[](size_t j) const {
            return {dim1_data[j], fixed_idx};
        }
    };

    const TwoDProxy operator[](size_t i) const {
        return {parent[i], fixed_last_idx};
    }
};

// 使用方式：直接通过视图访问原数据
FourDToThreeDView<int> y_view(x, 2);
// y_view[i][j][k] 等价于 x[i][j][k][2]

通用N维固定任意m个轴的解决方案 #

C++标准库无内置多维数组切片功能，要实现通用方案，需借助模板递归和代理类/视图处理任意维度与固定轴的组合：

核心思路 #

1. 用模板递归解析嵌套vector的维度，直到处理完所有固定轴；
2. 对无需固定的轴保留原有容器层级；
3. 优先用视图类映射原数据避免拷贝，若需副本则递归遍历构造新的嵌套vector。

简化通用副本生成示例 #

以下模板函数支持固定任意数量的轴（需指定轴索引和对应固定值）：

#include <vector>
#include <stdexcept>

// 递归终止：处理最内层vector，返回指定索引的元素
template<typename T>
T slice_single(const std::vector<T>& vec, const std::pair<size_t, size_t>& fixed_axis) {
    if (fixed_axis.second >= vec.size()) {
        throw std::out_of_range("Fixed index out of bounds");
    }
    return vec[fixed_axis.second];
}

// 递归处理嵌套vector
template<typename Container>
auto slice_multi(const Container& container, const std::vector<std::pair<size_t, size_t>>& fixed_axes, size_t current_dim = 0) {
    using InnerType = typename Container::value_type;
    using ResultInnerType = decltype(slice_multi(std::declval<InnerType>(), fixed_axes, current_dim + 1));
    std::vector<ResultInnerType> result;

    // 检查当前维度是否需要固定
    bool is_fixed = false;
    size_t fixed_idx = 0;
    for (const auto& axis : fixed_axes) {
        if (axis.first == current_dim) {
            is_fixed = true;
            fixed_idx = axis.second;
            break;
        }
    }

    if (is_fixed) {
        if (fixed_idx >= container.size()) {
            throw std::out_of_range("Fixed axis index out of bounds");
        }
        result.push_back(slice_multi(container[fixed_idx], fixed_axes, current_dim + 1));
    } else {
        result.reserve(container.size());
        for (const auto& elem : container) {
            result.push_back(slice_multi(elem, fixed_axes, current_dim + 1));
        }
    }
    return result;
}

// 使用方式：4维vector固定第3维（索引从0开始）为2
// auto y = slice_multi(x, {{3, 2}});

注意事项 #

• 上述通用代码为简化版，实际使用需完善错误处理（如轴索引越界、维度不匹配等）；
• 视图类是性能最优选择，但需保证原vector在视图使用周期内不被销毁；
• 若频繁处理多维数组，可考虑第三方库（如Eigen、Boost.MultiArray），它们原生支持高效多维切片操作。

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