C 11使用vector / initilizer列表的任何类型的动态多维数组

int main(int,char **)
{
        static const std::size_t d1{2};
        static const std::size_t d2{3};
        static const std::size_t d3{4};
        multi_vec<std::size_t> q({d1,d2,d3});

        for (std::size_t i1=0; i1 < d1; ++i1)
                for (std::size_t i2=0; i2 < d2; ++i2)
                        for (std::size_t i3=0; i3 < d3; ++i3)
                                q[{i1,i2,i3}]=foo(i1,i3);

        for (std::size_t i1=0; i1 < d1; ++i1)
                for (std::size_t i2=0; i2 < d2; ++i2)
                        for (std::size_t i3=0; i3 < d3; ++i3)
                                std::cout << "{"
                                        << i1 << ","
                                        << i2 << ","
                                        << i3 << "}=> "
                                        << foo(i1,i3) << "=="
                                        << q[{i1,i3}]
                                        << ((foo(i1,i3) == q[{i1,i3}])
                                              ? " good" : " ERROR")
                                << std::endl;
};

这实际上是使用lambdas和std :: for_each以及unique_ptr进行内存管理的好地方：

template <class T>
class multi_vec
{
public:
    using param=std::vector<size_t>;

    explicit multi_vec(const param& dimensions)
        : dim{dimensions},prod {1}
    {
        std::for_each(dim.begin(),dim.end(),[this] (std::size_t val)
        {
            mult.emplace_BACk(prod);
            prod *= val;
        } );
        ptr.reset(new T[prod]);
    }
    std::size_t capacity() const { return prod; }

    // undefined if elements in lookup != elemenets in dim
    // undefined if any element in lookup
        // is greater than or equal to corresponding dim element
    T& operator[](const param& lookup)
    {
        return ptr[get_offset(lookup)];
    }
    const T operator[](const param& lookup) const
    {
        return ptr[get_offset(lookup)];
    }
private:
    std::size_t get_offset(const param& lookup) const
    {
        std::size_t offset=0;
        auto mit=mult.begin();
        std::for_each(lookup.begin(),lookup.end(),[&offset,&mit] (std::size_t val)
        {
            offset+=*mit * val;
           ++mit;
        } );
        return offset;
    }
    param dim;
    param mult;
    std::size_t prod;
    std::unique_ptr<T[]> ptr;
};

这使用单维数组进行实际存储,并缓存乘法器以便重用由于正常的多维数组,例如x [2] [3] [4]不限制检查,超出范围被视为未定义,而不是不断检查可能有效的值.同样地,不检查diminsionality的查找,如果需要,可以添加静态成员来检查参数是否有效,就边界或维度而言.