在C ++中动态创建多维数组

Question

在C ++中动态创建多维数组的好方法（理解惯用方法/良好实践）是什么？

例如，让说我有树的整数w，h和d我想创建一个数组MyEnum my_array[w][h][d]。（当然，在编译时不知道w，h和d）。

最好使用嵌套的std :: vector还是使用new或其他东西？

额外的问题：是否可以动态设置尺寸？

Answer 1

通常，嵌套std::vector不是一个好主意。它通常是一个更好的计划来分配内存将举行您multidimensonal阵列作为连续块的整体，然后索引到它，就好像它是多维的。可以通过分配该内存块new，但是除非您需要对其分配方式进行精确控制（自定义分配器），否则建议坚持使用single std::vector。

创建一个类来管理可动态设置维数的资源并不难。组织此类的一种好方法是跟踪分配的内存，每个维度的大小以及每个维度的步幅模式。步幅描述了必须增加多少个元素才能沿给定维度到达下一个元素。

这允许高效的索引编制（仅指针算术），以及非常有效的重塑：只要元素的数量不变，这仅需要更改形状和步幅数组即可。

例：

这是一个非常基本的类，它将存储doubles 的动态多维数组。它以行优先顺序存储数据，这意味着最后一个索引变化最快。因此，对于2D数组，第一行是连续存储的，第二行是连续存储的，依此类推。

您可以根据需要调整数组的形状，更改维数。operator[]还显示了基本元素访问。该类没有别的花哨的东西，但是您可以扩展它以提供所需的任何功能，例如迭代器，对数据的数学运算，I / O运算符等。

/*! \file dynamic_array.h
 * Basic dynamic multi-dimensional array of doubles.
 */

#ifndef DYNAMIC_ARRAY_H
#define DYNAMIC_ARRAY_H

#include <vector>
#include <numeric>
#include <functional>

class
dynamic_array
{
    public:
        dynamic_array(const std::vector<int>& shape)
            : m_nelem(std::accumulate(shape.begin(), shape.end(),
                        1, std::multiplies<int>()))
            , m_ndim(shape.size())
            , m_shape(shape)
        {
            compute_strides();
            m_data.resize(m_nelem, 0.0);
        }

        ~dynamic_array()
        {
        }

        const double& operator[](int i) const
        {
            return m_data.at(i);
        }

        double& operator[](int i)
        {
            return m_data.at(i);
        }

        const double& operator[](const std::vector<int>& indices) const
        {
            auto flat_index = std::inner_product(
                    indices.begin(), indices.end(),
                    m_strides.begin(), 0);
            return m_data.at(flat_index);
        }

        double& operator[](const std::vector<int>& indices)
        {
            auto flat_index = std::inner_product(
                    indices.begin(), indices.end(),
                    m_strides.begin(), 0);
            return m_data.at(flat_index);
        }

        void reshape(const std::vector<int>& new_shape)
        {
            auto new_nelem = std::accumulate(
                    new_shape.begin(), new_shape.end(),
                    1, std::multiplies<int>());
            if (new_nelem != m_nelem) {
                throw std::invalid_argument("dynamic_array::reshape(): "
                        "number of elements must not change.");
            }
            m_nelem = new_nelem;
            m_ndim = new_shape.size();
            m_shape = new_shape;
            compute_strides();
        }

        const std::vector<int>& shape() const
        {
            return m_shape;
        }

        const std::vector<int>& strides() const
        {
            return m_strides;
        }

        int ndim() const
        {
            return m_ndim;
        }

        int nelem() const
        {
            return m_nelem;
        }

    private:
        int m_ndim;
        int m_nelem;
        std::vector<int> m_shape;
        std::vector<int> m_strides;
        std::vector<double> m_data;

        void compute_strides()
        {
            m_strides.resize(m_ndim);
            m_strides.at(m_ndim - 1) = 1;
            std::partial_sum(m_shape.rbegin(),
                    m_shape.rend() - 1,
                    m_strides.rbegin() + 1,
                    std::multiplies<int>());
        }
};

#endif // include guard

这是该功能的基本演示。

/*! \file test.cc
 * Basic test of the dynamic_array class.
 */
#include "dynamic_array.h"
#include <iostream>

int main(int /* argc */, const char * /* argv */[])
{
    dynamic_array arr({2, 3});
    std::cout << "Shape: { ";
    for (auto& each : arr.shape())
        std::cout << each << " ";
    std::cout << "}" << std::endl;

    std::cout << "Strides: { ";
    for (auto& each : arr.strides())
        std::cout << each << " ";
    std::cout << "}" << std::endl;

    // Reshape array, changing number of dimensions, but
    // keeping number of elements constant.
    arr.reshape({6});
    std::cout << "Shape: { ";
    for (auto& each : arr.shape())
        std::cout << each << " ";
    std::cout << "}" << std::endl;

    // Verify that the stride pattern has now also changed.
    std::cout << "Strides: { ";
    for (auto& each : arr.strides())
        std::cout << each << " ";
    std::cout << "}" << std::endl;

    return 0;
}

您可以使用编译测试程序g++ -std=c++14 -o test test.cc，假定定义该类的文件与相同test.cc。