当我调用解构器时，这会导致内存泄漏吗

我必须为我的Uni类做一个数据结构项目，该项目将实现一个带有链表的堆栈；简单的东西。在代码方面，我们得到了一些帮助，向我们展示了实现这种结构的正确方法。

堆栈类别：

class Stack
{
public:
    Stack(void)
    {
        top = NULL;     // Initialises defualt top node pointer.
    }
    ~Stack(void)
    {
        while (NodePop() != NULL){}
    }
    void Push(int value)    // Pushes a new node onto the stack.
    {
        Node* temp = new Node(value, top);  // Creates a temporary node with a value and makes it 
                                            // point to the top node as the next node in the stack.
        top = temp;                         // Temporary node becomes the top node in the stack.
    }
    Node* NodePop(void)
    {
        /* Remove top node from the stack */
        Node* temp = top;                       // Creates a temporary node to return, sets it to top node.
        if (top != NULL) top = top->getNext();  // Points the stacks top node to the next node in the list.
        return temp;                            // Returns a pointer to the popped node still in the heap.
    }
    int Pop(void)       // Pops the top node off of the stack. Returns the nodes value.
    {
        Node* temp = NodePop();     
        int valueReturn = 0;
        /* Sets the return value */
        if (temp != NULL)
        {
            valueReturn = temp->getVal();   // Set return value to the nodes value if there is a node left.
        }
        else
        {
            throw "Stack Empty";            // Throws exception if temp is NULL and stack is empty. 
        }
        delete temp;            // Deletes the node entirely from the heap.
        return valueReturn;
    }
private:
    Node* top;
};

节点类别：

class Node
{
public:
    Node(int value, Node* nextptr = NULL, Node* prevptr = NULL, int currentpriority = 0)
    {
        /* Set initial variables for the node at creation */
        this->value = value;
        this->next = nextptr;
        this->prev = prevptr;
        this->priority = currentpriority;
    }
    // bunch of getters and setters...
private:
    Node* next;     // Pointer to the next node.
    Node* prev;     // Pointer to the previous node.
    int priority;   // Stores the node priority as a number 0-9.
    int value;      // Stores the node value for printing.
};

我们不能更改任何类结构（我也很烦恼，NodePop（）应该是私有的，但w/e）。

因此，NodePop（）本质上从列表中删除了顶部节点，但没有删除它；它从链表中删除所有对它的引用，但从不从堆中删除它，它只是在Pop（）中从堆中被删除。一切都很好（除了可以公开调用NodePop（），但我不允许将其设为私有）。但当我调用析构函数时，必须使用NodePop（），而不是Pop（。

这是否意味着当NodePop（）从析构函数中运行时，节点永远不会从堆中删除

如果是，我该如何删除它们，因为它将运行nodePop（），如果我在一段时间内有它，do while，或者如果语句条件是总是有一个节点未删除