基于参数列表初始化的模板实参推导：动态多维数组视图类实现问询

嘿，我理解你想要一个类似N维std::string_view的非持有型数组视图——不绑定固定维度，访问时再指定维度数量和大小对吧？下面是我整理的实现方案，完全贴合你的需求：

核心类实现 #

这个类的核心是不接管数据所有权，只存原始数据的指针，通过operator()接受可变数量的维度和索引，动态计算元素的内存偏移：

#include <cstddef>
#include <utility>
#include <stdexcept>

template<typename T>
struct array_view {
    // 构造函数：只接收原始数据指针，不负责内存管理
    explicit array_view(T* data) : m_data(data) {}

    // 可变参数版operator()：先传维度大小列表，再传对应索引
    template<typename... DimSizes, typename... Indices>
    T& operator()(DimSizes... dims, Indices... indices) const {
        // 编译期检查：维度数必须和索引数一致
        static_assert(sizeof...(DimSizes) == sizeof...(Indices), 
                      "维度数量与索引数量不匹配");
        return *get_element_ptr(dims..., indices...);
    }

private:
    T* m_data;

    // 递归计算元素指针的辅助函数：处理前N-1个维度
    template<typename DimSize, typename Index, typename... RestDims, typename... RestIndices>
    T* get_element_ptr(DimSize dim, Index idx, RestDims... rest_dims, RestIndices... rest_indices) const {
        // 运行时边界检查，越界抛出异常
        if (idx < 0 || static_cast<size_t>(idx) >= static_cast<size_t>(dim)) {
            throw std::out_of_range("索引超出当前维度范围");
        }
        // 计算当前维度的步长：后续所有维度的大小乘积
        const size_t stride = calculate_stride(rest_dims...);
        return get_element_ptr(rest_dims..., rest_indices...) + idx * stride;
    }

    // 递归终止：处理最后一个维度
    template<typename DimSize, typename Index>
    T* get_element_ptr(DimSize dim, Index idx) const {
        if (idx < 0 || static_cast<size_t>(idx) >= static_cast<size_t>(dim)) {
            throw std::out_of_range("索引超出当前维度范围");
        }
        return m_data + static_cast<size_t>(idx);
    }

    // 计算步长的辅助函数：递归计算后续维度的乘积
    constexpr size_t calculate_stride() const {
        return 1; // 没有后续维度时，步长为1
    }

    template<typename DimSize, typename... RestDims>
    constexpr size_t calculate_stride(DimSize dim, RestDims... rest_dims) const {
        return static_cast<size_t>(dim) * calculate_stride(rest_dims...);
    }
};

使用示例 #

你可以用它来适配任意维度的数组，完全不需要提前绑定维度信息：

#include <iostream>

int main() {
    // 模拟3x4的二维数组
    int two_d_data[12] = {0,1,2,3,4,5,6,7,8,9,10,11};
    array_view<int> two_d_view(two_d_data);

    // 访问(1,2)：先传维度(3,4)，再传索引，对应data[1*4 + 2] = 6
    std::cout << two_d_view(3,4, 1,2) << std::endl; // 输出6

    // 当作一维数组访问：传维度(12)+索引(5)
    std::cout << two_d_view(12, 5) << std::endl; // 输出5

    // 模拟2x3x2的三维数组
    int three_d_data[12] = {0,1,2,3,4,5,6,7,8,9,10,11};
    array_view<int> three_d_view(three_d_data);
    // 访问(1,2,0)：偏移量=1*3*2 + 2*2 +0 = 10，对应元素10
    std::cout << three_d_view(2,3,2, 1,2,0) << std::endl; // 输出10

    return 0;
}

关键特性说明 #

• 非持有型设计：和std::string_view一样，视图不管理内存，使用时要保证原始数据的生命周期长于视图。
• 完全动态维度：维度数量和大小都不需要在模板中固定，每次访问时灵活传入，适配各种多维结构。
• 安全检查：内置越界检查，抛出std::out_of_range异常，如果你追求极致性能可以移除这部分逻辑。
• 通用性：支持任意数量的维度，只要索引数量和维度数量匹配就能正常工作。

可扩展优化点 #

• const版本支持：可以重载一个const array_view，返回const T&，适配只读场景。
• 无符号类型约束：可以把维度和索引限制为size_t这类无符号类型，避免负数输入的问题。
• 编译期优化：如果维度大小是编译期常量，可以用constexpr修饰步长计算，进一步提升性能。

内容的提问来源于stack exchange，提问作者MC ΔT