Question

我想找到在C ++中实现三维整数数组的安全方法，使用指针算术/动态内存分配，或者使用STL技术，如矢量。

基本上我希望我的整数数组维度看起来像：

[ x ][ y ][ z ]

x和y在20-6000范围内 z已知并且等于4.

Answer 1

查看Boost multi-dimensional array库。这是一个例子（改编自Boost文档）：

#include "boost/multi_array.hpp"

int main() {
  // Create a 3D array that is 20 x 30 x 4
  int x = 20;
  int y = 30;
  int z = 4;

  typedef boost::multi_array<int, 3> array_type;
  typedef array_type::index index;
  array_type my_array(boost::extents[x][y][z]);

  // Assign values to the elements
  int values = 0;
  for (index i = 0; i != x; ++i) {
    for (index j = 0; j != y; ++j) {
      for (index k = 0; k != z; ++k) {
        my_array[i][j][k] = values++;
      }
    }
  }
}

Answer 2

每对方括号都是一个解除引用操作（当应用于指针时）。例如，以下几行代码是等效的：

x = myArray[4];
x = *(myArray+4);

x = myArray[2][7];
x = *((*(myArray+2))+7);

要使用建议的语法，您只需取消引用第一个取消引用返回的值。

int*** myArray = (some allocation method, keep reading);
//
// All in one line:
int   value = myArray[x][y][z];
//
// Separated to multiple steps:
int** deref1 = myArray[x];
int*  deref2 = deref1[y];
int   value = deref2[z];

要分配这个数组，你只需要认识到你实际上没有一个三维的整数数组。你有一个整数数组数组。

// Start by allocating an array for array of arrays
int*** myArray = new int**[X_MAXIMUM];

// Allocate an array for each element of the first array
for(int x = 0; x < X_MAXIMUM; ++x)
{
    myArray[x] = new int*[Y_MAXIMUM];

    // Allocate an array of integers for each element of this array
    for(int y = 0; y < Y_MAXIMUM; ++y)
    {
        myArray[x][y] = new int[Z_MAXIMUM];

        // Specify an initial value (if desired)
        for(int z = 0; z < Z_MAXIMUM; ++z)
        {
            myArray[x][y][z] = -1;
        }
    }
}

取消分配此数组遵循类似的过程来分配它：

for(int x = 0; x < X_MAXIMUM; ++x)
{
    for(int y = 0; y < Y_MAXIMUM; ++y)
    {
        delete[] myArray[x][y];
    }

    delete[] myArray[x];
}

delete[] myArray;

Answer 3

下面是在每个阵列的一个内存块中使用C或C ++创建3D数组的简单方法。不需要使用BOOST（即使它很好），或者在具有多个间接的行之间拆分分配（这非常糟糕，因为它通常在访问数据时会给性能带来很大的损失并且会破坏内存）。

唯一要理解的是没有多维数组，只有数组（数组）。最里面的索引是记忆中最远的。

#include <stdio.h>
#include <stdlib.h>

int main(){

    {
        // C Style Static 3D Arrays
        int a[10][20][30];
        a[9][19][29] = 10;
        printf("a[9][19][29]=%d\n", a[9][19][29]);
    }

    {
        // C Style dynamic 3D Arrays
        int (*a)[20][30];
        a = (int (*)[20][30])malloc(10*20*30*sizeof(int));
        a[9][19][29] = 10;
        printf("a[9][19][29]=%d\n", a[9][19][29]);
        free(a);
    }

    {
        // C++ Style dynamic 3D Arrays
        int (*a)[20][30];
        a = new int[10][20][30];
        a[9][19][29] = 10;
        printf("a[9][19][29]=%d\n", a[9][19][29]);
        delete [] a;
    }

}

对于您的实际问题，由于可能存在两个未知维度，因此我的提案存在问题，只允许一个未知维度。有几种方法可以解决这个问题。

好消息是使用变量现在可以与C一起使用，它被称为可变长度数组。您可以查看here了解详细信息。

    int x = 100;
    int y = 200;
    int z = 30;

    {
        // C Style Static 3D Arrays 
        int a[x][y][z];
        a[99][199][29] = 10;
        printf("a[99][199][29]=%d\n", a[99][199][29]);
    }

    {
        // C Style dynamic 3D Arrays
        int (*a)[y][z];
        a = (int (*)[y][z])malloc(x*y*z*sizeof(int));
        a[99][199][29] = 10;
        printf("a[99][199][29]=%d\n", a[99][199][29]);
        free(a);
    }

如果使用C ++，最简单的方法可能是使用运算符重载来坚持数组语法：

    {
        class ThreeDArray {
            class InnerTwoDArray {
                int * data;
                size_t y;
                size_t z;
                public:
                InnerTwoDArray(int * data, size_t y, size_t z)
                    : data(data), y(y), z(z) {}

                public:
                int * operator [](size_t y){ return data + y*z; }
            };

            int * data;
            size_t x;
            size_t y;
            size_t z;
            public:
            ThreeDArray(size_t x, size_t y, size_t z) : x(x), y(y), z(z) {
                data = (int*)malloc(x*y*z*sizeof data);
            }

            ~ThreeDArray(){ free(data); }

            InnerTwoDArray operator [](size_t x){
                return InnerTwoDArray(data + x*y*z, y, z);
            }
        };

        ThreeDArray a(x, y, z);
        a[99][199][29] = 10;
        printf("a[99][199][29]=%d\n", a[99][199][29]);
    }

上面的代码有一些用于访问InnerTwoDArray的间接成本（但是一个好的编译器可能可以优化它）但是在堆上分配的数组只使用一个内存块。这通常是最有效的选择。

显然即使上面的代码仍然简单明了，STL或BOOST做得很好，因此无需重新发明轮子。我仍然相信知道它可以轻松完成是很有趣的。

Answer 4

使用向量：

std::vector< std::vector< std::vector< int > > > array3d;

如果元素已经添加，则可以通过array3d [x] [y] [z]访问每个元素。（例如通过push_back）

Answer 5

应该注意的是，对于所有意图和目的，您只处理2D数组，因为第三个（也是最不重要的）维度是已知的。

如果您事先不知道阵列的每个维度中有多少条目，那么使用STL或Boost是非常好的方法，因为它们将为您提供动态内存分配，如果您的话，我推荐这些方法中的任何一种数据集基本上保持静态，或者它主要只接收新条目而不是很多删除。

但是，如果您事先了解了有关数据集的内容，例如总共将存储多少项，或者如果要稀疏填充数组，那么最好使用某种散列/存储桶功能，并使用XYZ索引作为您的密钥。在这种情况下，假设每个维度的条目不超过8192（13位），您可以使用40位（5字节）密钥。或者，假设总共有4个Z条目，您只需使用26位XY键。这是速度，内存使用和动态分配之间更有效的权衡之一。

Answer 6

使用STL来管理内存比使用new / delete有很多好处。选择如何表示数据取决于您计划如何使用它。一个建议是隐藏实现决策并向一维STL向量提供三维get / set方法的类。

如果您确实需要创建自定义3D矢量类型，请先调查Boost。

// a class that does something in 3 dimensions

class MySimpleClass
{
public:

  MySimpleClass(const size_t inWidth, const size_t inHeight, const size_t inDepth) :
   mWidth(inWidth), mHeight(inHeight), mDepth(inDepth)
   {
       mArray.resize(mWidth * mHeight * mDepth);
   }


  // inline for speed
  int Get(const size_t inX, const size_t inY, const size_t inZ) {
     return mArray[(inZ * mWidth * mHeight) + (mY * mWidth) + mX];
  }

  void Set(const size_t inX, const size_t inY, const size_t inZ, const int inVal) {
     return mArray[(inZ * mWidth * mHeight) + (mY * mWidth) + mX];
  }

  // doing something uniform with the data is easier if it's not a vector of vectors
  void DoSomething()
  {
     std::transform(mArray.begin(), mArray.end(), mArray.begin(), MyUnaryFunc);
  }

private:

  // dimensions of data
  size_t mWidth;
  size_t mHeight;
  size_t mDepth;

  // data buffer
  std::vector< int > mArray;
};

Answer 7

彼得的建议当然是好的，但你必须记住的一件事是，如果建立大阵列，它可能会很慢。每次矢量容量改变时，所有数据都必须被复制（向量的'n'个向量）。

C ++中的三维整数数组

7 个答案: