如何在C ++中創建類似於Python的numpy數組的數組？

Question

我正在將Python program to C++轉換Python program to C++格式。

Python有一個以下格式的數組。

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

什么是創建類似於boxes數組的C++數組的最佳方法？

Answer 1

我想是的

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

或者，為了避免Humam Helfawi指出的堆棧溢出問題，你可以使用std::vector （so heap memory）如下

   auto boxes2 = std::vector<
                    std::vector<
                       std::vector<
                          std::vector<
                             std::vector<float>>>>>
                                (1U, std::vector<
                                        std::vector<
                                           std::vector<
                                              std::vector<float>>>>
                                   (300U, std::vector<
                                             std::vector<
                                                std::vector<float>>>
                                      (4U, std::vector<
                                              std::vector<float>>
                                         (5U, std::vector<float>
                                             (1U, 0.0f)))));

或者，正如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{} };

Answer 2

事實上，numpy分配一個連續的數組存儲，並且strides用於根據多維索引計算內存偏移量。 要在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}]);
}

Answer 3

#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);
        }
    }