从指针返回对象时出现意外的析构函数调用

我正在尝试重新创建我在 C# 中制作的优先级队列实现，以C++作为一个项目来跳入C++，但很多细微差别让我感到困惑。队列被设计为一个模板，用于处理任何给定的类 T。队列将显式使用表示称为优先级对的对象的结构：指向 T 对象的指针和关联的优先级值 (int)。

这样做的目的是允许队列中比较的实际对象(T)完全独立，并且只指向。我可能没有明确需要结构来完成此操作，但这就是我的做法。

队列实现中的重要部分：

template <class T>
class PriorityQueue
{
public:
PriorityQueue(const int maxSizeIn)
{
maxSize = maxSizeIn;
queueArray = new PriorityPair<T>*[maxSize];
currentHeapSize = 0;
}
~PriorityQueue()
{
cout << "Destroy Queue with size: " << currentHeapSize << endl;
for (int i = 0; i < currentHeapSize; i++)
{
delete (PriorityPair<T>*)queueArray[i];
}
delete[] queueArray;
}
private:
PriorityPair<T>** queueArray;

优先级对的结构：

template <class T>
struct PriorityPair
{
PriorityPair(int valueIn, T* objectIn)
{
_PriorityValue = valueIn;
_Object = objectIn;
};
~PriorityPair()
{
cout << "Destroy Pair for object :(" << *_Object << "):  << endl;
}
int _PriorityValue;
T* _Object;
};

在测试过程中，我发现调用 PeekTop 方法似乎会导致 PriorityPair 调用其析构函数。我最好的猜测是，由于未能理解语言的某些细微差别，我不小心创建了一个临时的。

下面是速览方法：

T PeekTop()
{
if (IsEmpty())
return nullptr;
else
return *((PriorityPair<T>)(*queueArray[0]))._Object; 
}

此外，下面是插入操作(最低效率插入，不执行堆/队列操作)：

int InsertElement(PriorityPair<T>* elementIn)
{
//do not insert nulls --
if (elementIn == nullptr)
return -2;
//we could user std::vector or manually expand the array, but a hard max is probably sufficient
if (currentHeapSize == maxSize)
{
return -1;
}
//insert the pointer to the new pair element in at the index corresponding to the current size, then increment the size
queueArray[currentHeapSize++] = elementIn;
return 0;
}

总的来说，我有以下内容：

PriorityQueue<string> queue = PriorityQueue<string>(10);
string s1 = "string1";
int code = queue.InsertElement(new PriorityPair<string>(5, &s1));
string i = queue.PeekTop();
cout << "-------n";
cout << i << endl;

这似乎有效，因为它确实正确插入了元素，但我不明白新对的行为是否符合我的预期。当我运行代码时，我的优先级对的析构函数被调用两次。这在调用函数 PeekTop 时特别发生。在队列的生存期内一次，在队列超出范围并被销毁时一次。

下面是上述代码的输出：

Code: 0
Destroy Pair for object :(string1): with priority :(5):
-------
string1
Destroy Queue with size: 1
Destroy Pair for object :(): with priority :(5):

第一个析构函数调用正确显示字符串及其值，但在第二个中我们可以看到字符串本身已超出范围(这很好，也是预期的)。