Question

我确信以前曾经问过这个问题，但搜索条款因我的具体情况而失败基本上，我正在创建一个2D磁贴引擎。为了提高整体效率并减少一些开销，我决定实现自己的简单内存管理容器......

我正在使用以下代码：

Tile.h

//Tile class
class CTile
{
public:
    CTile();
    ~CTile();
    unsigned int row;
    unsigned int column;
};

//Container class
class CTileLayer
{
public:
    CTileLayer(unsigned int nRows, unsigned int nCols, float w, float h);
    ~CTileLayer();

protected:
    CTile** m_tiles;
    unsigned long count;

    void Allocate(unsigned int nRows, unsigned int nCols, float w, float h);
    void Free();
};

Tile.cpp

#include "Tile.h"


CTile::CTile() : row(0), column(0)
{
}

CTile::~CTile()
{
}


CTileLayer::CTileLayer(unsigned int nRows, unsigned int nCols, float w, float h) : m_tiles(NULL)
{
    Allocate(nRows, nCols, w, h);
}

CTileLayer::~CTileLayer()
{
    if(m_tiles != NULL) Free();
}

void CTileLayer::Allocate(unsigned int nRows, unsigned int nCols, float w, float h)
{
    unsigned int column = 0, row = 0;

    if(m_tiles != NULL) Free();
    m_tiles = new CTile*[count = (nRows * nCols)];

    for( unsigned long l = 0; l < count; l++ ) {
        m_tiles[l] = new CTile[count];
        m_tiles[l]->column = column + 1;
        m_tiles[l]->row = row + 1;
        //
        //...
        //
        if(++column > nCols) {
            column = 0;
            row++;
        }
    }
}

void CTileLayer::Free()
{
    delete [] *m_tiles;
    delete [] m_tiles;
    m_tiles = NULL;
    count = 0;
}

因此，通过查看每个磁贴的分配/释放方式，可以肯定地说这不会产生任何内存泄漏吗？

如果愿意，在确保每个对象的析构函数被调用的同时，最合适的方法是什么？我应该遍历数组，而是手动删除每个对象吗？

Answer 1

为什么不这样做：

CTile* m_tiles;

m_tiles = new CTile[nRows*nColumns];

delete[] m_tiles;

Answer 2

您为每个new CTile[count]调用m_tiles[l]次计数。

因此，您需要为每个delete[]调用m_tiles[l]次计数。

然而，目前尚不清楚count有什么用处。您应该将nRows和nColumns用于数组的两个层。现在你分配了nRows * nRows * nColumns * nColumns个CTile个实例，这可能太多了。

而是尝试

m_tiles = new CTile*[nRows];

m_tiles[l] = new CTile[nColumns];

会在内存泄漏中使用delete []这样结束吗？

2 个答案: