为C+中的3D数组分配连续内存+； 我可以分配连续的内存来分配C++中的2D数组。我不知道如何处理3D阵列。我已经读过一些帖子，但还没有找到解决办法 #include <iostream> using namespace std; int main(int argc, char **argv){ cout << "Ints have size " << sizeof(int) << endl; int rows= 2; int cols= 3; int **i= new int*[rows]; int size= rows*cols; i[0]= new int[size]; for(int j= 1; j < rows; j++) { i[j]= &i[0][j*cols]; } for(int j= 0; j < rows; j++) { for(int k= 0; k < cols; k++) { cout << j << " " << k << " " << &i[j][k] << endl; } } delete[] i; return 0; } #包括 使用名称空间std； int main（int argc，字符**argv）{ cout

数组的数组

（3D数组）

只不过是一个数组，它包含每个索引中另一个数组的引用。

---

您只需分配第一个

2D数组

，然后为此数组的每个索引分配另一个数组。

具有

p

平面的3d数组，每个平面都有

R

行和

C

列需要

p*R*C

元素。您可以立即分配它们，例如：

Element *p = new Element[P*R*C];

然后要访问坐标

（p，r，c）

处的元素，可以使用以下公式：

int index = (p*R + r)*C + c;

要使事物可读，一个简单的解决方案是创建一个类

template<typename T>
struct Matrix3D {
    int P, R, C;
    std::vector<T> elements;

    Matrix3D(int P, int R, int C)
        : P(P), R(R), C(C), elements(P*R*C)
    { }

    T& operator()(int p, int r, int c) {
        return elements[(p*R + r)*C + c];
    }
};

模板
结构矩阵x3d{
int P，R，C；
std：：向量元素；
矩阵x3d（整数P，整数R，整数C）
：P（P）、R（R）、C（C）、元素（P*R*C）
{ }
运算符（）（int p，int r，int c）{
返回元素[（p*R+R）*C+C]；
}
};

在本例中，我使用

std:：vector

来存储元素，因为这使所有权/复制更简单，并且仍然保证所有元素在内存中都是连续的。如果要手动分配存储，则需要更多的代码

---

如果在编译时知道大小，那么您可以使用

p

、

R

和

C

模板参数，并使用

std:：array

成员而不是

std:：vector

。这应该会提高性能，因为整个类最终将成为堆中的单个内存块，并允许常量元素访问的乘法技巧。

如果必须分配的空间必须是连续的，则必须分配一个“新”空间，否则内存将不连续

这看起来像这样：

int d1 = 10; // first
int d2 = 10; // second
int d3 = 10; // third dimension

int* array3D = new int[d1 * d2 * d3];

这样，您就为3D阵列分配了enoug空间，现在必须将其映射到3D

array3D[(1*d1*d2) + (2*d2) + (3)]; // access element at 1,2,3

使用此功能，您可以将分配给该一维阵列的每个点映射到三维空间中的唯一点

正如你可能看到的，这是非常容易出错的。所以你不应该这样做

永远不要使用new/delete分配如下数组：

int d1 = 10; // first
int d2 = 10; // second
int d3 = 10; // third dimension

int* array3D = new int[d1 * d2 * d3];

使用

std:array

或

std:：vector

为您处理此问题。 使用原始new/delete会导致错误，如果使用new分配了任何内容，而您忘记删除它，或者您忽略了某些内容，则会出现内存泄漏

void test(){
    int* a = new int[20];
    // do stuff with a...
    if(error)
        return; // oops this is a leak

    delete a; // only executed if there was no error,
}

如果您知道数组在编译时必须有多大，并且它永远不需要更改，则可以使用

std:：array

另一方面，如果在编译时不知道大小，则可以使用std:：vector，它可以在程序运行时更改

std::array<int, 10> test1; // creates a fixed size array of size 10 and type int.
std::vector<int>    test2(10); // creates an array that can change at runtime:
test2.push_back(2);            // the vector now has size 11 and the last element is equal to 2

---

让我们备份一下，您不是在分配数组，而是在分配指针的存储空间。创建一个1D数组，该数组有足够的存储空间用于整个3D数组，然后手动执行所有索引，以将三维映射到1。在2D中，您可以扩展到3D。重要的问题是，数组大小在编译时已知，还是从fi读取le或user，可以是任何东西？@hyde是的，编译时就知道了。3D数组也可以是三维数组，在任何地方都没有指针。你所描述的通常被称为“锯齿数组”，因为不同的行可以有不同的大小。是的！但用户没有特别要求classicé数组。他可以用for循环分配索引成员，只需为每个成员使用一个常量作为大小。问题要求“连续内存”.@hyde Continous意味着在内存中只占用一个空间范围，而不是所有列都必须具有相同的大小，不是吗？@cocool97如果您创建指针，然后为它们分配内存，则整个内存将不连续-尤其是当数组大于一个虚拟页时。