如何在C+中创建数组+；与Python类似'；s numpy数组？

我正在将

Python程序转换为C++

格式

Python具有以下格式的数组

boxes = np.zeros((1, 300, 4, 5, 1), dtype = np.float)

创建一个与

box

数组类似的

C++

数组的最佳方法是什么

auto boxes = std::array<
                std::array<
                   std::array<
                      std::array<
                         std::array<float, 1U>, 300U>, 4U>, 5U>, 1U> {};

或者，正如n.caillou所建议的

using boxA5 = std::array<
                 std::array<
                    std::array<
                       std::array<
                          std::array<float, 1U>, 300U>, 4U>, 5U>, 1U>;

auto boxes3 = std::unique_ptr<boxA5> { new boxA5{} };

使用boxA5=std:：array<
std：：数组<
std：：数组<
std：：数组<
标准：阵列，300U>，4U>，5U>，1U>；
auto boxes3=std:：unique_ptr{new boxes5{}；

#包括
#包括
向量v；
v、 调整大小（1）；
v[0]。调整大小（300）；
对于（int i＝0；i），NUMPY分配了一个连续的数组存储，并且用于基于多维索引计算内存偏移。为了在C++中实现类似的结果，可以编写这样的内容：

#include <vector>
#include <memory>
#include <cstddef>
#include <cstdio>

class NDArray {
    std::vector<size_t> m_dims, m_strides;
    std::unique_ptr<float[]> m_buf;

    public:
        NDArray(std::vector<size_t> dims):
            m_dims{std::move(dims)}
        {
            m_strides.resize(m_dims.size());
            size_t stride = 1;
            for (int i = m_dims.size() - 1; i >= 0; -- i) {
                m_strides[i] = stride;
                stride *= m_dims[i];
            }
            m_buf.reset(new float[stride]);
        }

        float& operator[] (std::initializer_list<size_t> idx) {
            size_t offset = 0;
            auto stride = m_strides.begin();
            for (auto i: idx) {
                offset += i * *stride;
                ++ stride;
            }
            return m_buf[offset];
        }
};

int main() {
    NDArray arr({2, 3});
    arr[{1, 2}] = 3;
    arr[{1, 1}] = 2;
    printf("%g\n", arr[{1, 2}]);
}

#包括
#包括
#包括
#包括
班轮{
向量m_dims，m_steps；
std：：唯一的_ptrm_buf；
公众：
数据阵列（标准：：矢量dims）：
m_dims{std:：move（dims）}
{
m_步长.resize（m_dims.size（））；
步幅大小=1；
对于（int i=m_dims.size（）-1；i>=0；--i）{
m_跨步[i]=跨步；
步幅*=m_-dims[i]；
}
m_buf.重置（新浮动[步幅]）；
}
浮点和运算符[]（标准：：初始值设定项\u列表idx）{
尺寸偏差=0；
自动步幅=m_步幅。开始（）；
用于（自动i:idx）{
偏移量+=i**步；
++大步走；
}
返回m_buf[偏移]；
}
};
int main（）{
NDArray-arr（{2,3}）；
arr[{1，2}]=3；
arr[{1，1}]=2；
printf（“%g\n”，arr[{1，2}]）；
}
使用外部库。Eigen是一个选项，但也有其他选项。根据DavidW所说的，Eigen是一个更像numpy的选项。我将查看这些库。@batuman请确认您希望能够编写
x[0][185][3][4][0]
关于结构：这里的结构将是您的数据类型。如果只有双精度，则不需要。我正在考虑制作一个包含int a、float[]b、float[]c、float[]c的结构d，int e；@HumamHelfawi-谢谢；添加了一个
std:：vector
解决方案。还有明显的
独特之处_ptr@batuman-抱歉；也许我不了解pyton，但……据我所知，您要求为1x300x5x4x1提供多维数组floats@n.caillou-很明显，但我没有考虑；谢谢#include#include numpy数组是连续的数组，它是静态的，我知道，不是一个向量树，也可以映射到或拷贝到一个麻木数组，因为接口C++和Python只会返回指针，但是TER将是原始指针而不是矢量。如果任何C++程序员都会说“EW”。按照这个想法，整个Phyton\C++API都是在原始指针上工作的，没有办法绕过它
#include <iostream>
#include <vector>  
vector<vector<vector<vector<double> > > > v;
    v.resize(1);
    v[0].resize(300);
    for(int i=0;i<300;i++)
    {
        v[0][i].resize(4);
        for(int j=0;j<4;j++)
        {
            v[0][i][j].resize(5);
            for(int l=0;l<5;l++)
                v[0][i][j][l]=double(0.0);
        }
    }

#include <vector>
#include <memory>
#include <cstddef>
#include <cstdio>

class NDArray {
    std::vector<size_t> m_dims, m_strides;
    std::unique_ptr<float[]> m_buf;

    public:
        NDArray(std::vector<size_t> dims):
            m_dims{std::move(dims)}
        {
            m_strides.resize(m_dims.size());
            size_t stride = 1;
            for (int i = m_dims.size() - 1; i >= 0; -- i) {
                m_strides[i] = stride;
                stride *= m_dims[i];
            }
            m_buf.reset(new float[stride]);
        }

        float& operator[] (std::initializer_list<size_t> idx) {
            size_t offset = 0;
            auto stride = m_strides.begin();
            for (auto i: idx) {
                offset += i * *stride;
                ++ stride;
            }
            return m_buf[offset];
        }
};

int main() {
    NDArray arr({2, 3});
    arr[{1, 2}] = 3;
    arr[{1, 1}] = 2;
    printf("%g\n", arr[{1, 2}]);
}