Question

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

这是用Object指针填充2D数组的方法：

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*，然后再删除向量本身？

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

Answer 1

使用Object ***要求您完成并删除每个Object Pointer，每个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都需要相应的删除调用）。

vector<vector<Object*>> matrix;

... // some code here

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

如果您在编译时知道2-D数组的大小，则可以实现避免2-D数组的内存管理，并简单地管理Object指针。

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

但我仍然喜欢矢量，因为它们具有额外的好处，能够动态调整自身，不像数组，所以你不必担心事先知道大小。

2D矢量/动态阵列

1 个答案: