Question

我正在使用析构函数，复制构造函数和赋值运算符实现HashMap类。当我创建一个HashMap对象并向其添加一个键和值并尝试将其分配给一个新的空对象时，我得到一个＆＃34;双重自由或腐败＆＃34;错误。但是，如果我在不向HashMap添加任何键的情况下执行相同操作，则代码运行正常。我还注意到，如果我从赋值运算符重载实现中注释掉arrayCopy函数，代码也可以正常运行，但是当然我分配的对象不会有数组的副本。 BackTrace还说错误就在这一行：

else if (node->next == nullptr)

感谢任何帮助，谢谢！

HashMap::HashMap()
    :hasher{hash}, Buckets_Array{new Node* [initialBucketCount]}, currentBucketCount{initialBucketCount}, sz{0}

{
    fillArray(Buckets_Array, currentBucketCount);


}


HashMap::HashMap(const HashMap& hm)
    :hasher{hm.hasher}, Buckets_Array{new Node*[hm.currentBucketCount]},currentBucketCount{hm.currentBucketCount}, sz{hm.sz}
{
    arrayCopy(hm.Buckets_Array, Buckets_Array, currentBucketCount);

}


HashMap::~HashMap()
{
    for(int i = 0; i < currentBucketCount; i++)
    {
        deleteLinkedList(Buckets_Array[i]);
    }

    delete[] Buckets_Array;
}


HashMap& HashMap::operator=(const HashMap& hm)
{
    if (this != &hm)
    {

        Node** newNodeArray = new Node*[currentBucketCount];
        fillArray(newNodeArray, currentBucketCount);
        arrayCopy(hm.Buckets_Array, newNodeArray, currentBucketCount);
        currentBucketCount = hm.currentBucketCount;
        sz = hm.sz;

        for (int i = 0; i < currentBucketCount; i++)
        {
            deleteLinkedList(Buckets_Array[i]);
        }

        delete[] Buckets_Array;
        Buckets_Array = newNodeArray;

    }

    return *this;
}

void HashMap::add(const std::string& key, const std::string& value)
{
    // REHASH IF EXCEEDED LOAD FACTOR
    double futureLoadFactor = double((sz + 1))/double(currentBucketCount);

    if (futureLoadFactor > maximumLoadFactor)
    {
        std:: cout << "REHASHING KEYS....." << std::endl;
        rehashKeys();
    }

    unsigned int index = getIndex(key);

    if (!checkExists(Buckets_Array[index], key, value))
    {

        if (Buckets_Array[index] == nullptr)
        {
            Node* n = new Node;
            n->key = key;
            n->value = value;
            n->next = nullptr;
            Buckets_Array[index] = n;
        }

        else
        {

            addToEnd(Buckets_Array[index], key, value);

        }

        sz += 1;
    }


}

以下是我使用的一些帮助成员函数：

void HashMap::fillArray(Node** nodeArray, int size)
{
    for (int i = 0; i < size; i++)
    {
        nodeArray[i] = nullptr;
    }
}



void HashMap::arrayCopy(Node** source, Node**& target, int arrysz)
{

    for (int i = 0; i < arrysz; i++)
    {
        if (source[i] != nullptr)
        {
            Node* temp = source[i];
            target[i] = temp;
        }

        else
        {
            target[i] = nullptr;
        }
    }


}

void HashMap::deleteLinkedList(Node* node)
{


    if (node == nullptr)
    {
        return;
    }
    else if (node->next == nullptr)
    {
        delete node;
    }
    else
    {

        Node* next = node->next;
        delete node;
        deleteLinkedList(next);
    }

}

void HashMap::addToEnd(Node*& node, std::string key, std::string value)
{

    if ( node == nullptr )
    {
        Node* n = new Node;
        n->key = key;
        n->value = value;
        n->next = nullptr;
        node = n;

    }


    else
    {

        addToEnd(node->next, key, value);

    }

}

这个

HashMap HP;
HashMap HH;
HashMap HP.add("k", "v");
HH = HP;

给了我一个＆＃34;双重免费或损坏错误＆＃34;。

但是，如果我删除HP.add部分程序运行没有错误

Answer 1

在arrayCopy中，将指向一个哈希映射的元素的指针复制到另一个哈希映射中。因此，在两个映射中有相同的指针，因此两次删除相同的对象。

您需要分配一个新元素并将数据从一个对象复制到另一个对象中。

复制构造函数和assignemnt运算符重载在C ++中不起作用

1 个答案: