Question

我有两个名为arrContainer和pArrContainer的模板类。 arrContainer的行为很像一个vector类，它基本上是一个动态数组的包装器，用于简化动态数组的内存管理，而pArrContainer的工作方式与arrContainer基本相同，只不过它用于动态指针数组。我们的想法是它将清除它用于动态数组的内存，以及清除数组中指针的内存。

此外，我有一个班级董事会，代表棋盘游戏。它用来做这个的基本成员是arrC_board，一个arrContainer＆lt; pArrContainer＆LT;瓦片LT;片＆GT; ＆GT; ＆GT; Tile是用于表示电路板上每个磁贴的模板类，而Piece是用于表示电路板上各个磁贴的类。

这里描述了Tile的内部结构。由于它用于Piece，tmp将是Piece：

template <typename tmp>
class Tile
{
protected:
    ...
    tmp* tmp_occupant;
public:
    Tile();
    ~Tile();
    tmp* getOccupant() const {return tmp_occupant;}
    ...
};

董事会的内部结构如下所示：

template <typename tmp>
class Board
{
protected:
    arrContainer < pArrContainer < Tile < tmp > > > arrC_board;
    int i_rows;
    int i_columns;
public:
    //Creates a 0x0 board (No elements!)
    Board();
    //Creates a IxJ board (Row x Column)
    Board(int I, int J);
    //Deletes the memory inside of all the tiles as well.
    ~Board();
    tmp* getElement(int I, int J) const;
    ...
};

但是当我调用Board的getElement函数时：

template <typename tmp>
tmp* Board<tmp>::getElement(int I, int J) const
{
    if (I >= 0 && J >= 0 && I < i_rows && J < i_columns)
    {
        Piece* occupant = arrC_board[I][J]->getOccupant();
        return occupant;
    }
    else
        ....
}

并转到Piece* occupant = arrC_board[I][J]->getOccupant();部分，getOccupant()返回正确的值，但在将值实际分配给occupant之前调用pArrContainer的析构函数。

为什么会这样？

作为参考，包括以下函数体：

pArrContainer的重载下标运算符：

template <typename tmp>
tmp* pArrContainer<tmp>::operator[] (const int index)
{
    if (index >= size)
    {
        ...//this part isnt executed
    }
    else
        return heldArray[index];
}

arrContainer的下标运算符看起来与pArrContainer相同。 Tile的getOccupant()函数：

tmp* getOccupant() const {return tmp_occupant;}

我为这个问题所需的阅读量道歉。

为什么这个语句会调用这个析构函数？

0 个答案: