如何分配和訪問3D，4D，5D陣列？

Question

我怎麼能在contigious方式分配的3D，4D，5D陣列與一個malloc和訪問單個項目？

像這樣：

int* array = malloc(sizeof(int) * width * height); 
int item = array[x + y * width]; 

Answer 1

作爲回答這裏https://stackoverflow.com/a/19725907/2684539：

看專門computeIndex/computeIndexes。

#include <cstddef> 

#include <vector> 

template<typename T> 
class MultiArray 
{ 
public: 
    explicit MultiArray(const std::vector<size_t>& dimensions) : 
     dimensions(dimensions), 
     values(computeTotalSize(dimensions)) 
    { 
     assert(!dimensions.empty()); 
     assert(!values.empty()); 
    } 

    const T& get(const std::vector<size_t>& indexes) const 
    { 
     return values[computeIndex(indexes)]; 
    } 
    T& get(const std::vector<size_t>& indexes) 
    { 
     return values[computeIndex(indexes)]; 
    } 

    size_t computeIndex(const std::vector<size_t>& indexes) const 
    { 
     assert(indexes.size() == dimensions.size()); 

     size_t index = 0; 
     size_t mul = 1; 

     for (size_t i = 0; i != dimensions.size(); ++i) { 
      assert(indexes[i] < dimensions[i]); 
      index += indexes[i] * mul; 
      mul *= dimensions[i]; 
     } 
     assert(index < values.size()); 
     return index; 
    } 

    std::vector<size_t> computeIndexes(size_t index) const 
    { 
     assert(index < values.size()); 

     std::vector<size_t> res(dimensions.size()); 

     size_t mul = values.size(); 
     for (size_t i = dimensions.size(); i != 0; --i) { 
      mul /= dimensions[i - 1]; 
      res[i - 1] = index/mul; 
      assert(res[i - 1] < dimensions[i - 1]); 
      index -= res[i - 1] * mul; 
     } 
     return res; 
    } 

private: 
    size_t computeTotalSize(const std::vector<size_t>& dimensions) const 
    { 
     size_t totalSize = 1; 

     for (auto i : dimensions) { 
      totalSize *= i; 
     } 
     return totalSize; 
    } 

private: 
    std::vector<size_t> dimensions; 
    std::vector<T> values; 
}; 

int main() 
{ 
    MultiArray<int> m({3, 2, 4}); 

    m.get({0, 0, 3}) = 42; 
    m.get({2, 1, 3}) = 42; 

    for (size_t i = 0; i != 24; ++i) { 
     assert(m.computeIndex(m.computeIndexes(i)) == i); 
    } 
    return 0; 
} 

Answer 2

甲3D陣列是二維陣列的陣列。 4D陣列是3D陣列的陣列。你只是乘以你的其他維度。例如，三維陣列可以以這種方式進行分配：

int *array = malloc(sizeof(int) * width * height * depth); 

四維陣列中可以通過你的其他尺寸乘以進行：

int *array = malloc(sizeof(int) * width * height * depth * other_dimension); 

等爲5D，6D，等等。陣列。

可以通過使用這樣的訪問的元素（3D陣列，容易擴展），假設可以訪問所述陣列的寬度和高度：

int get_element(int x, int y, int z) 
{ 
    return array[(z * width * height) + (y * width) + x]; 
} 

對於4D數組：

int get_element(int x, int y, int z, int dimension_4) 
{ 
    return array[(dimension_4 * width * height * depth) + (z * width * height) + (y * width) + x]; 
} 

Answer 3

數組是通過分配作爲單一維度的性質。您可以通過計算它們的索引的方式爲它們提供維度。您需要分配的大小是標量元素的大小乘以打算使用的任意多個維度中每個維度的元素數量，例如，如果您需要一個10 x 20 x 30的4字節元素數組，則需要乘以4 x 10 x 20 x 30來獲得你需要的malloc的大小。然後，我可能會寫一個函數，如my_index(int i, int j, int k)，它將計算任何有效（i，j，k）組合的一維索引。這個想法可以擴展到任意多個維度。