修复C++多维数组类linearise函数的可变参数传递问题（免va_list）

嘿，我来帮你搞定这个linearise函数的问题！你说它已经是模板可变参数函数，但没法用常规可变模板技巧？其实是可以的——咱们可以用递归展开（兼容C11/14）或者**C17折叠表达式**来实现，完全不需要va_list这种C风格的可变参数机制，还能保证类型安全。

问题根源分析 #

你遇到的编译错误，大概率是因为原来的linearise尝试用va_list处理可变参数，但可变模板参数是编译期展开的，而va_list是运行期处理的，编译器没法匹配两者的类型和数量。咱们需要用C++模板原生的可变参数展开方式来替换。

解决方案1：递归展开（C++11/14兼容） #

这种方式通过递归逐个处理每个索引，计算每个索引对应的“跨度”（stride，即后面所有维度的乘积），然后累加得到一维偏移量。

#include <vector>
#include <cassert>

template <typename T>
class multidimensional_array {
private:
    std::vector<T> m_data;
    std::vector<size_t> m_dimensions;

    // 递归终止：没有更多索引时返回0
    size_t linearise_impl() const {
        return 0;
    }

    // 递归处理每个索引
    template <typename FirstIdx, typename... RestIdxs>
    size_t linearise_impl(FirstIdx idx, RestIdxs... rest, size_t current_dim) const {
        // 计算当前索引对应的跨度：后面所有维度的乘积
        size_t stride = 1;
        for (size_t i = current_dim + 1; i < m_dimensions.size(); ++i) {
            stride *= m_dimensions[i];
        }
        // 累加当前索引的偏移 + 剩余索引的偏移
        return static_cast<size_t>(idx) * stride + linearise_impl(rest..., current_dim + 1);
    }

public:
    // 构造函数：初始化维度和数据
    multidimensional_array(std::initializer_list<size_t> dims) : m_dimensions(dims) {
        size_t total_size = 1;
        for (size_t dim : dims) {
            total_size *= dim;
        }
        m_data.resize(total_size);
    }

    // 对外暴露的linearise函数
    template <typename... Idxs>
    size_t linearise(Idxs... indexes) const {
        static_assert(sizeof...(indexes) == m_dimensions.size(), "索引数量必须和数组维度一致！");
        return linearise_impl(indexes..., 0);
    }

    // 元素访问运算符
    template <typename... Idxs>
    T& operator()(Idxs... indexes) {
        return m_data[linearise(indexes...)];
    }

    template <typename... Idxs>
    const T& operator()(Idxs... indexes) const {
        return m_data[linearise(indexes...)];
    }
};

解决方案2：C++17折叠表达式（更简洁） #

如果你的项目可以用C++17或更高版本，折叠表达式能让代码更紧凑，不需要递归：

#include <vector>
#include <array>
#include <utility> // 用于index_sequence

template <typename T>
class multidimensional_array {
private:
    std::vector<T> m_data;
    std::vector<size_t> m_dimensions;

    // 辅助函数：用index_sequence匹配索引和对应的跨度
    template <typename... Idxs, size_t... Is>
    size_t linearise_fold_impl(std::index_sequence<Is...>, Idxs... indexes) const {
        // 先计算每个维度的跨度：从后往前算，最后一个维度跨度为1
        std::array<size_t, sizeof...(Idxs)> strides;
        strides.back() = 1;
        for (int i = static_cast<int>(strides.size()) - 2; i >= 0; --i) {
            strides[i] = strides[i + 1] * m_dimensions[i + 1];
        }
        // 折叠表达式：每个索引乘以对应跨度，然后累加
        return (static_cast<size_t>(indexes) * strides[Is] + ...);
    }

public:
    multidimensional_array(std::initializer_list<size_t> dims) : m_dimensions(dims) {
        size_t total_size = 1;
        for (size_t dim : dims) {
            total_size *= dim;
        }
        m_data.resize(total_size);
    }

    template <typename... Idxs>
    size_t linearise(Idxs... indexes) const {
        static_assert(sizeof...(indexes) == m_dimensions.size(), "索引数量必须和数组维度一致！");
        // 生成索引序列，传递给辅助函数
        return linearise_fold_impl(std::make_index_sequence<sizeof...(Idxs)>(), indexes...);
    }

    // 元素访问运算符
    template <typename... Idxs>
    T& operator()(Idxs... indexes) {
        return m_data[linearise(indexes...)];
    }

    template <typename... Idxs>
    const T& operator()(Idxs... indexes) const {
        return m_data[linearise(indexes...)];
    }
};

测试代码 #

现在你可以正常使用元素访问了，比如：

#include <iostream>

int main() {
    multidimensional_array<int> arr({2, 3, 4});
    arr(1, 2, 3) = 42;
    std::cout << arr(1, 2, 3) << std::endl; // 现在编译完全没问题！
    return 0;
}

关键优化点 #

1. 编译期检查：用static_assert确保传入的索引数量和数组维度一致，提前发现错误。
2. 类型安全：所有索引都是模板参数，编译器会检查类型是否可转换为size_t，避免运行期错误。
3. 效率：跨度计算可以提前缓存（比如在构造时预计算所有跨度），进一步优化性能——如果数组维度不动态变化的话，还可以把维度设为模板参数，让跨度计算完全在编译期完成。

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