运行时控制C++向量维度的可行实现方案咨询

方案一：使用std::variant存储多维度类型 #

既然C++模板是编译期特性，我们可以用std::variant把所有可能的向量类型打包成一个可在运行时切换的类型，避免大量if-else分支。

示例代码 #

#include <vector>
#include <variant>
#include <iostream>

// 定义支持的多维度向量类型，可按需扩展
using MultiDimVector = std::variant<
    std::vector<int>,
    std::vector<std::vector<int>>,
    std::vector<std::vector<std::vector<int>>>
>;

// 用std::visit处理不同维度的向量
void print_vector(const MultiDimVector& vec) {
    std::visit([](const auto& v) {
        // 递归打印任意维度的向量
        auto print = [](const auto& val, auto& self) -> void {
            if constexpr (std::is_same_v<decltype(val), const int&>) {
                std::cout << val << " ";
            } else {
                std::cout << "[ ";
                for (const auto& elem : val) {
                    self(elem, self);
                }
                std::cout << "] ";
            }
        };
        print(v, print);
        std::cout << "\n";
    }, vec);
}

int main() {
    int runtime_depth = 2; // 运行时确定维度
    MultiDimVector vec;

    if (runtime_depth == 1) {
        vec = std::vector<int>{1,2,3};
    } else if (runtime_depth == 2) {
        vec = std::vector<std::vector<int>>{{1,2}, {3,4}};
    } else if (runtime_depth == 3) {
        vec = std::vector<std::vector<std::vector<int>>>{{{1}, {2}}, {{3}, {4}}};
    }

    print_vector(vec);
    return 0;
}

这个方案类型安全，直接复用std::vector的成熟实现，无需自行管理内存。若需支持更多维度，只需在MultiDimVector的variant列表中添加对应类型即可。

方案二：自定义动态维度容器 #

如果不想受variant的类型列表限制，可以实现一个基于一维数组的动态维度容器，通过索引计算模拟多维访问。

实现思路 #

• 用一维std::vector<T>存储所有元素，保证内存连续
• 用std::vector<size_t>记录各维度的大小（比如二维对应{行数, 列数}）
• 实现索引计算逻辑，将多维坐标转换为一维数组的索引

示例代码 #

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

template<typename T>
class DynamicMultiDimVector {
private:
    std::vector<T> data;
    std::vector<size_t> dimensions;
    std::vector<size_t> stride; // 各维度的步长，用于计算索引

    void calculate_stride() {
        stride.resize(dimensions.size());
        if (dimensions.empty()) return;
        stride.back() = 1;
        for (int i = dimensions.size() - 2; i >= 0; --i) {
            stride[i] = stride[i+1] * dimensions[i+1];
        }
    }

public:
    // 构造函数：传入维度列表（比如{2,3}表示2行3列的二维向量）
    explicit DynamicMultiDimVector(const std::vector<size_t>& dims) : dimensions(dims) {
        size_t total_size = 1;
        for (size_t d : dims) {
            total_size *= d;
        }
        data.resize(total_size);
        calculate_stride();
    }

    // 多维索引访问（支持任意维度）
    T& at(const std::vector<size_t>& indices) {
        if (indices.size() != dimensions.size()) {
            throw std::invalid_argument("Indices count doesn't match dimensions");
        }
        size_t idx = 0;
        for (size_t i = 0; i < indices.size(); ++i) {
            if (indices[i] >= dimensions[i]) {
                throw std::out_of_range("Index out of bounds");
            }
            idx += indices[i] * stride[i];
        }
        return data[idx];
    }

    // 获取维度信息
    const std::vector<size_t>& get_dimensions() const {
        return dimensions;
    }
};

int main() {
    int runtime_depth = 2;
    std::vector<size_t> dims;
    if (runtime_depth == 1) {
        dims = {3}; // 一维，3个元素
    } else if (runtime_depth == 2) {
        dims = {2,3}; // 二维，2行3列
    } else if (runtime_depth == 3) {
        dims = {2,2,2}; // 三维，2x2x2
    }

    DynamicMultiDimVector<int> vec(dims);
    // 赋值示例（二维）
    if (runtime_depth == 2) {
        vec.at({0,0}) = 1;
        vec.at({0,1}) = 2;
        vec.at({0,2}) = 3;
        vec.at({1,0}) = 4;
        vec.at({1,1}) = 5;
        vec.at({1,2}) = 6;

        // 打印二维向量
        for (size_t i = 0; i < dims[0]; ++i) {
            for (size_t j = 0; j < dims[1]; ++j) {
                std::cout << vec.at({i,j}) << " ";
            }
            std::cout << "\n";
        }
    }
    return 0;
}

这个方案完全摆脱编译期类型限制，维度可由运行时参数决定，适合需要动态扩展维度的场景。虽然需要自行实现索引计算，但逻辑清晰，性能与一维vector接近。

方案三：类型擦除（不推荐，仅作补充） #

如果需要更灵活的类型兼容，可以用类型擦除技术：定义抽象基类，为每个维度的vector实现派生类，再用基类指针或std::unique_ptr存储。但这种方式会带来虚函数调用的额外开销，类型安全性也不如前两种方案，非特殊场景不建议使用。

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