在C+中处理巨大的多维数组+； 我设计了一个类似于MiCeCrt的C++游戏，它在内存中保存了大量的地形数据。通常，我希望在内存中存储一个数组，即[5][4][5][50][50]。这还不错，因为它相当于大约100mb的虚拟内存，因为我的结构只有大约8个字节

然而，我很难找到处理这个问题的最佳方法。我确实希望它位于虚拟内存中，但显然不在堆栈上。我一直在犯这样的错误：在堆栈上创建这个数组会导致堆栈溢出。我想做的事情如下。这只是我拼凑的代码，给你一个我正在做的例子，我的机器上有语法正确的代码，我只是不想把文章弄得乱七八糟

typedef struct modelBlock
{
    // Information about the blocks
} BLOCK;

typedef struct modelGrid
{
    bool empty;

    BLOCK blocksArray[50][50][50];

} GRID;


class Parent
{
     Child* child;
     Parent(void);
}

Parent::Parent()
{
    Child c;
    child = &c;
}

class Child
{
     GRID grids[5][4][5];
}

然而，每次我这样做，都会导致堆栈溢出（合适的网站选择对吗？）。我曾尝试使用基于指针的数组，但由于数据丢失超出其范围，我遇到了很多麻烦

---

如果有人能告诉我如何将数据存储在堆上而不是堆栈上，或者我应该使用其他方法创建数组，我将非常感谢您的帮助。由于开销的原因，我希望避免使用向量，但我不确定它有多大。

如果希望在堆上创建类，请使用新的：

Child * c = new Child;

---

然后当然要删除它，或者最好还是使用智能指针。

如果要在堆上创建类，请使用新的：

Child * c = new Child;

---

然后当然删除它，或者最好还是使用智能指针。

我通过将所有数据放在二进制文件中来实现这一点。我计算了数据的偏移量，并在需要时使用seek（）和read（）获取数据。open（）调用非常慢，因此您应该在程序生命周期内保持文件打开。

我通过将所有数据放在二进制文件中来实现这一点。我计算了数据的偏移量，并在需要时使用seek（）和read（）获取数据。open（）调用非常慢，因此您应该在程序的生命周期内保持文件打开。

为了准确地执行您试图执行的操作，您必须将所有内容声明为指针（以及指向指针的指针指向指向指向指针的指针），然后分别分配每个指针

德苏

一个更好的选择是简单地将ginormous块分配到一个块中，并使用多个变量和指针算法来到达正确的位置

---

编辑：没有注意，也没有注意到你的构造器。这不仅不是让你的孩子在免费商店中得到分配的方法，也是创造引发未定义行为的情境的一种很好的方法。当构造函数完成时，您的孩子将消失，指向它的指针将无效。我想知道你是否不应该在编写游戏之前先浏览一些基本教程。

为了准确地完成你要做的事情，你必须将所有内容声明为指针（指针指向指针指向指针指向指针），然后分别分配每一个

德苏

一个更好的选择是简单地将ginormous块分配到一个块中，并使用多个变量和指针算法来到达正确的位置

---

编辑：没有注意，也没有注意到你的构造器。这不仅不是让你的孩子在免费商店中得到分配的方法，也是创造引发未定义行为的情境的一种很好的方法。当构造函数完成时，您的孩子将消失，指向它的指针将无效。我想知道你是否不应该在编写游戏之前先浏览一些基本教程。

使用使用如果你想在堆上分配一些东西，请使用

新建

#include <memory>

class Parent
{
    std::auto_ptr<Child> child; // use auto_ptr for dynamically-allocated members
    Parent(const Parent&); // You probably don't want to copy this giant thing
public:
    Parent();
};

Parent::Parent()
  : child(new Child) // initialize members with an initializer list
{
}

C++中的P>结构只是一个默认情况下所有成员都是公共的类；与类一样，您可以引用结构类型的名称，而无需使用
struct
标记。对于不带参数的函数，也不需要指定
void

boost：：multi_数组（链接在PigBen的答案中）是一个比原始数组更好的选择。
如果您想在堆上分配一些东西，请使用
new

#include <memory>

class Parent
{
    std::auto_ptr<Child> child; // use auto_ptr for dynamically-allocated members
    Parent(const Parent&); // You probably don't want to copy this giant thing
public:
    Parent();
};

Parent::Parent()
  : child(new Child) // initialize members with an initializer list
{
}

C++中的P>结构只是一个默认情况下所有成员都是公共的类；与类一样，您可以引用结构类型的名称，而无需使用
struct
标记。对于不带参数的函数，也不需要指定
void

boost:：multi_阵列（链接在PigBen的答案中）是一个比原始阵列更好的选择。
这里有一些可以工作的东西，可以在没有boost依赖的情况下构建。一个缺点是它不使用[]样式的引用元素，但成本很低，可以添加

template<class T>
class Matrix {
    unsigned char* _data;
    const size_t _depth;
    const size_t _cols;
    const size_t _rows;
public:
    Matrix(const size_t& depth, const size_t& rows, const size_t& cols):
        _depth(depth),
        _rows(rows), 
        _cols(cols) {
        _data = new unsigned char [depth * rows * cols * sizeof(T)];
    }
    ~Matrix() {
        delete[] _data;
    }
    T& at(const size_t& depthIndex, const size_t& rowIndex, const size_t& colIndex) const {
        return *reinterpret_cast<T*>(_data + ((((depthIndex * _cols + colIndex) * _rows) + rowIndex) * sizeof(T)));
    }
    const size_t& getDepth() const {
        return _depth;
    }
    const size_t& getRows() const {
        return _rows;
    }
    const size_t& getCols() const {
        return _cols;
    }
};

int _tmain(int argc, _TCHAR* argv[])
{
    Matrix<int> block(50, 50, 50);
    size_t d, r, c;
    for (d = 0; d < block.getDepth(); d++) {
        for (r = 0; r < block.getRows(); r++) {
            for (c = 0; c < block.getCols(); c++) {
                block.at(d, r, c) = d * 10000000 + r * 10000 + c;
            }
        }
    }
    for (d = 0; d < block.getDepth(); d++) {
        for (r = 0; r < block.getRows(); r++) {
            for (c = 0; c < block.getCols(); c++) {
                assert(block.at(d, r, c) == d * 10000000 + r * 10000 + c);
            }
        }
    }
return 0;
}

模板
类矩阵{
无符号字符*_数据；
const size\u t\u depth；
const size\u t\u cols；
const size\u t\u行；
公众：
矩阵（常数大小和深度、常数大小和行、常数大小和列）：
_深度（深度），
_行(行),，
_科尔斯（科尔斯）{
_数据=新的无符号字符[深度*行数*列数*大小（T）]；
}
~Matrix（）{
删除[]_数据；
}
T&at（常数大小和深度索引、常数大小和行索引、常数大小和共索引）常数{
return*reinterpret\u cast（_data+（（（depthIndex*_cols+colIndex）*\u rows）+行索引）*sizeof（T））；
}
常量大小\u t&getDepth（）常量{
返回深度；
}
常量大小\u t&getRows（）常量{
返回_行；
}
常量大小\u t&getCols（）常量{
返回_cols；
}
};
int _tmain（int argc，_TCHAR*argv[]
{
矩阵块（50，50，50）；
尺寸d、r、c；
对于（d=0；d#include <iostream>

class Block
{
    public:
    // Information about the blocks
    int data;
};


class Grid
{
    public:
    bool empty;
    Block (*blocks)[50][50];

    Grid() : empty(true) {
    }

    void makeRoom(){
        this->blocks = new Block[50][50][50];
        this->empty = false;
    }

    ~Grid(){
        if (!this->empty){
            delete [] this->blocks;
        }
    }
};


class Parent
{
    public:
    Grid (* child)[4][5];

    Parent()
    {
        this->child = new Grid[5][4][5];
    }

    ~Parent()
    {
        delete [] this->child;
    }
};


main(){
    Parent p;
    p.child[0][0][0].makeRoom();
    if (!p.child[0][0][0].empty){
        Block (* grid)[50][50] = p.child[0][0][0].blocks;
        grid[49][49][49].data = 17;
    }

    std::cout << "item = " 
              << p.child[0][0][0].blocks[49][49][49].data 
              << std::endl;
}

class Parent
{
    public:
    Grid child[5][4][5];
};