我想找出在C ++中使用指针算术/动态内存分配，或者使用STL技术(例如向量)来实现整数的三维数组的安全方法。
本质上，我希望整数数组的尺寸看起来像：
x和y的范围是20-6000
z是已知的，等于4。
看一下Boost多维数组库。这是一个示例(改编自Boost文档)：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| #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++;
}
}
}
} |
以下是在每个阵列的一块内存中使用C或C ++创建3D阵列的一种直接方法。无需使用BOOST(即使它很好)，也无需在具有多个间接访问的行之间分配分配(这很糟糕，因为在访问数据时通常会带来很大的性能损失，并且会碎片化内存)。
唯一要了解的是，没有多维数组，只有数组(数组)的数组。最里面的索引是内存中最远的。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
| #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\
", 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\
", 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\
", a[9][19][29]);
delete [] a;
}
} |
对于您的实际问题，由于可能存在两个未知维度，因此我的建议存在一个问题，因为它仅允许一个未知维度。有几种方法可以解决这个问题。
好消息是，现在使用变量可与C一起使用，称为变量长度数组。您在这里查看详细信息。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| 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\
", 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\
", a[99][199][29]);
free(a);
} |
如果使用C ++，最简单的方法可能是使用运算符重载来坚持数组语法：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
| {
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\
", a[99][199][29]);
} |
上面的代码在访问InnerTwoDArray时有一些间接开销(但是好的编译器可能会对其进行优化)，但是仅使用一个内存块来分配在堆上的数组。通常这是最有效的选择。
显然，即使上面的代码仍然简单明了，STL或BOOST也能很好地完成，因此不需要重新发明轮子。我仍然相信知道它可以轻松完成很有趣。
每对方括号都是解引用操作(应用于指针时)。例如，以下几对代码行是等效的：
1
2
| x = myArray[4];
x = *(myArray+4); |
1
2
| x = myArray[2][7];
x = *((*(myArray+2))+7); |
要使用建议的语法，您只需对第一个取消引用返回的值进行取消引用。
1
2
3
4
5
6
7
8
9
| 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]; |
要分配此数组，您只需要认识到实际上没有三维整数数组即可。您有一个整数数组的数组。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| // 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;
}
}
} |
取消分配此数组与分配它类似的过程：
1
2
3
4
5
6
7
8
9
10
11
| 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; |
与向量：
1
| std::vector< std::vector< std::vector< int > > > array3d; |
如果已经添加了元素，则可以使用array3d [x] [y] [z]访问每个元素。 (例如，通过push_back)
与使用new / delete相比，使用STL管理内存有很多优点。如何表示数据的选择取决于您计划如何使用它。一个建议是隐藏执行决策并为一维STL向量提供三维获取/设置方法的类。
如果您确实认为需要创建自定义3d矢量类型，请先研究Boost。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
| // 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;
}; |
应该注意的是，出于所有意图和目的，您只处理2D数组，因为已知第三(也是最低有效)维度。
如果您事先不知道数组每个维度中将有多少个条目，那么使用STL或Boost是非常好的方法，因为它们将为您提供动态内存分配，如果您的数据集是保持基本上是静态的，或者大多数情况下仅接收新条目而不删除很多条目。
但是，如果您事先了解数据集的知识，例如总共将存储大约多少个项目，或者如果要稀疏地填充数组，则最好使用某种哈希/存储桶函数，并使用XYZ索引作为键。在这种情况下，假设每个维度的条目数不超过8192(13位)，则可以使用40位(5字节)的密钥来获得。或者，假设始终有4 x Z个条目，则只需使用26位XY键即可。这是速度，内存使用和动态分配之间更有效的折衷之一。
Pieter的建议当然很好，但是您要记住的一件事是，在构建大型阵列的情况下，它可能会非常缓慢。每次向量容量更改时，都必须复制所有数据(向量的n个向量)。
