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

Question

I'm trying to recreate a priority queue implementation I made in C# to C++ as a project to jump into C++ with, but a lot of the nuance is tripping me up. The queue is designed as a template to work on any given class T. The queue will explicitly work with a struct representing objects called Priority Pairs: a pointer to a T object and an associated priority value (int).

The goal of this is to allow the actual objects (the T's) being compared in the queue to be completely separate and only ever be pointed to. I probably don't explicitly need the struct to accomplish this but this is how I'm doing it.

The important bits from the queue implementation:

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;

The Struct for PriorityPair:

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;
};

During the course of my testing, I've found that calling my PeekTop method seems to cause a PriorityPair to have its destructor called. My best guess is that I am accidentally creating a temporary one due to a failure to understand some nuance of the language.

Here's the peek method:

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

Additionally, here is the insert operation (minimally effective insert, does no heap/queue operations):

    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;
    }

In the main I have the following:

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;

This appears to work, insofar that it does insert the element correctly, but I don't understand if that new pair is behaving as I intend it to. When I run the code the destructor for my Priority Pair is getting called twice. This happens specifically when the function PeekTop is called. Once during the queue's lifetime and once when the queue goes out of scope and is destroyed.

Here is the output from the above code:

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

The first destructor call shows the string correctly with its value, but in the second we can see that the string itself has gone out of scope (which is fine and expected).

Answer 1

Aside from the names starting with an underscore, which as people have pointed out in the comments, your problem appears to be in the line return *((PriorityPair<T>)(*queueArray[0]))._Object . Let's look at this piece by piece, from the inside and working our way out.

queueArray is a PriorityPair<T>** , as declared in PriorityQueue . This could be read as “pointer to pointer to PriorityPair<T> ”, but in your case it looks like you mean it to be “raw array of pointer to PriorityPair<T> ”, which is also a valid reading. So far so good.

queueArray[0] is a PriorityPair<T>*& , or “reference to pointer to PriorityPair<T> ”. References are pretty invisible in C++, and this just means you're dealing with the actual first element of the array and not a copy. Again, this is a reasonable thing to ask for when trying to peek at the top of the queue.

*queueArray[0] is simply a PriorityPair<T>& , or “reference to PriorityPair<T> ”. Again, the reference here just means you're dealing with the actual thing being pointed to by queueArray[0] , and not a copy.

(PriorityPair<T>)(*queueArray[0]) is a PriorityPair<T> , the result of casting the one you already had to a new one. This creates a temporary PriorityPair<T> , which is the one you see destroyed later . There is no programmatic reason to do this cast (your IntelliSense issues are a different question and I don't know enough about VS to comment about them); it's already the right type. You can verify that it's a different one that's destroyed if you add this to the output, since this is a pointer to the current object and a temporary would need to live somewhere else in memory.

((PriorityPair<T>)(*queueArray[0]))._Object is a T* , or “pointer to T ”. In fact, it points to the T that was stored for the top of the priority queue, which is good.

And finally, the full expression *((PriorityPair<T>)(*queueArray[0]))._Object dereferences this to give a T , and the return statement returns a copy of that T . This isn't affecting the behavior you're seeing, but if you added destructor calls to the objects you tested with, it would. It would probably be more efficient to return a reference to the T , which would forgo the copying, by changing the return type from T to T& or T const& .

Other issues I noticed, not related to this question, which you might find useful when learning C++ (not a comprehensive list; I mostly wasn't looking for these):

• Both of your constructors should use initializer lists and have empty bodies (yes, new expressions can go in initializer lists, I think literally everybody I've spoken to about it either asked this the first time or assumed incorrectly, including me). This will somewhat more efficient and much more idiomatic.
• You don't need to implement a destructor for the PriorityPair (except for learning the nuances of the language); it's what's known as a Plain Old Data (POD) type. If you wanted the PriorityPair 's destruction to delete the T s you would need that, but you want the T s to be managed completely separately.
• As people pointed out in the comments, you aren't allowed to use those identifier names yourself in case the compiler or standard library want them. This might be fine, it might cause problems for you at compile time, or it might appear to work correctly but send all your users' browser history and emails to their parents and/or employers. That last is unlikely, but the C++ standard doesn't forbid it; this is what undefined behavior means. Other allowed behaviors are creating a black hole to destroy the Earth and shooting demons out of your nose , but these are even less likely in practice.
• I think like you have the destructor logic for PriorityQueue correct, and it's easy to mess that sort of thing up. Congratulations!