1

我正在尝试使用 2D 数组来跟踪以网格方式布置的一些对象。我希望 2d 数组的每个元素都包含一个Object*. Object作为我定义的类。然而，使用这些东西并不容易。

这是我用Object指针填充二维数组的方法：

int xDim; 
//how far to go in the x direction
//x's Dimension that is

Object *** test; //the highest level pointer used

test = new  Object ** [xDim];
//add horizontal array of Object **

for(int fillPos=0; fillPos < xDim; fillPos++){
    //point each Object ** to  a new Object * array 
    //add column arrays
    test[fillPos] = new Object*[zDim];
}

我的意图是使用这个数组的Object指针指向 的子类Object，比如说childObj。我的意图是以这种方式使用它们。

for (int xPos=0; xPos < xDim; xPos++){
    for(int zPos=0; zPos < zDim; zPos++){
        //pointing each Object * in the 2D array to
        //a new childObj
        test[xPos] [zPos] = new childObj;
    }
}

我意识到这在记忆方面可能是一个真正的麻烦。我在问这是否是处理这种情况的好方法。也许像这样 的东西vector< <vector<Object*> >可以更好地工作？向量会很好地管理删除以避免内存泄漏吗？或者也许我只需要遍历向量并在摆脱向量之前调用delete每个向量？Object*

那么，我应该使用现有的数组还是向量？每种方法可能存在哪些问题？

4

1 回答 1

0

使用Object ***要求您按顺序依次删除 each Object Pointer、 each Array of Object Pointers，然后最后删除最外层Array of Object**的 。在我看来，这为粗心和错误留下了很大的空间。

for (int xPos=0; xPos < xDim; xPos++) {
    for (int zPos=0; zPos < zDim; zPos++) {
        delete test[xPos][yPos];  // delete the object ptr
    }
    delete[] test[xPos];          // delete each array of object ptr
}
delete[] test;                    // delete the array of array of object ptrs

我更喜欢向量方法，因为向量是局部范围的。动态分配可能相当昂贵，应尽可能避免。

因此，对于矢量方法，您只需要删除 Object ptrs。（一个好的经验法则是每次调用 new 都需要调用相应的 delete）。 

vector<vector<Object*>> matrix;

... // some code here

for each (vector<Object*> vec in matrix)
    for each (Object* oPtr in vec)
        delete oPtr;

如果您在编译时知道二维数组的大小，则可以达到相同的效果，即避免二维数组的内存管理，而只需管理对象指针。

Object * matrix[xDim][yDim];  // xDim and yDim are compile-time constants

但是我仍然喜欢向量，因为它们具有与数组不同的是能够动态调整自身大小的额外好处，因此您不必担心预先知道大小。

于 2013-01-16T21:54:56.987 回答