我的哈希表 C++ 中的内存泄漏

我创建了一个哈希表类并以这种方式编写了它的析构函数

HashMap::~HashMap()
{
    for (int i=0; i<cap; i++)
    {
        Node* ptr = Hashtable[i];
        while (ptr)
        {
            Node* delptr;
            delptr=ptr;
            ptr=ptr->next;
            delete delptr;
        }
    }
    delete [] Hashtable;
}

既然它有一个析构函数，为什么它保持泄漏内存？

这是我实现构造函数的方式

HashMap::HashMap()
{
    Hashtable= new Node* [INITIAL_BUCKET_COUNT];
    sz=0;
    cap=INITIAL_BUCKET_COUNT;
    hashfunction=defaulthashfunction;
}

additem 函数是：

void HashMap::add(const std::string& key, const std::string& value)
{
    int index = hashfunction(key)%cap;;
    Node* ptr=Hashtable[index];
    Node* newnode=new Node;
    if (contains(key)==false)
    {
        if (ptr == nullptr)
        {
            newnode->key=key;
            newnode->value=value;
            newnode->next=NULL;
            Hashtable[index]=newnode;
        }
        else
        {
            newnode->key=key;
            newnode->value=value;
            newnode->next=NULL;
            while(ptr->next != NULL)
            {
                ptr = ptr->next;
            }
            ptr->next=newnode;
         }}
    if (loadFactor() > 0.8)
    {
        int newcap = cap*2+1;
        Node** newhash = new Node* [newcap];
        rehash(newhash, Hashtable, cap, newcap);
        for (int i=0; i <cap; i++)
        {
            Node* ptr=Hashtable[i];
            while (ptr)
            {
                Node* delptr;
                delptr=ptr;
                ptr=ptr->next;
                delete delptr;
            }
        }
        delete [] Hashtable;
        Hashtable=newhash;
    }
}

这是我的重新哈希函数，唯一的错误始终是这一行：节点* nnode = 新节点;如果我把这段代码放在循环的一侧，错误就会变成 20，它表明问题出在我的析构函数中。但是在调整我的哈希表大小之前，它没有错误，我测试了几次。为什么 rehash 函数会保留泄漏内存？

void HashMap::rehash(Node** newhash, Node** oldhash, int oldcap, int newcap)
{
    for (int x=0; x<newcap; x++)
    {
        newhash[x]=NULL;
    }
    //Node* nnode = new Node;
    for (int i = 0; i<oldcap; i++)
    {
        Node* ptr=oldhash[i];
        while (ptr!=NULL)
        {
            int index = hashfunction(ptr->key)%newcap;
            Node* nptr=newhash[index];
            Node* nnode = new Node;
            if (nptr==NULL)
            {
                nnode->key=ptr->key;
                nnode->value=ptr->value;
                nnode->next=NULL;
                newhash[index]=nnode;
            }
            else
            {
                while (nptr->next != NULL)
                {
                    nptr=nptr->next;
                }
                nnode->key=ptr->key;
                nnode->value=ptr->value;
                nnode->next=NULL;
                nptr->next=nnode;
                }
            ptr=ptr->next;
         }
    }
}

--插入--