Перегрузка оператора присваивания не работает, когда происходит перестановка в хэш-функции

Question

Я реализую HashMap, у меня есть конструктор копирования и функция перегрузки оператора присваивания. При повторном обращении в HashMap функция перегрузки оператора присваивания вызывает ошибку сегментации. Однако, если не было перехвата, оператор присваивания работает нормально. Я думаю, что, возможно, я слишком долго смотрел на код, и если бы новый набор глаз проверял код, проблема стала бы очевидной.

Благодаря

Вот мои основные функции-члены:

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*[hm.currentBucketCount]; 

     fillArray(newNodeArray, hm.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) 
    { 
     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::rehashKeys() 
{ 
    currentBucketCount = (currentBucketCount * 2) + 1; 
    Node** tempBucketsArry = new Node* [currentBucketCount]; 
    fillArray(tempBucketsArry, currentBucketCount); 

    std::cout << "MAX INDEX: " << currentBucketCount/2 << std::endl; 
    for (int i = 0; i < currentBucketCount/2; i++) 
    { 
     hashLinkedList(Buckets_Array[i], tempBucketsArry); 
     deleteLinkedList(Buckets_Array[i]); 

    } 
    delete[] Buckets_Array; 
    Buckets_Array = tempBucketsArry; 

} 


void HashMap::hashLinkedList(Node* node, Node**& node_arry) 
{ 
    if (node != nullptr) 
    { 
     int newIndex = getIndex(node->key);   
     addToEnd(node_arry[newIndex], node->key, node->value); 
     hashLinkedList(node->next, node_arry); 

    } 
} 

void HashMap::copyNode(Node* sourceNode, Node* targetNode) 
{ 


    targetNode->key = sourceNode->key; 
    targetNode->value = sourceNode->value; 
    sourceNode = sourceNode->next; 

    while (sourceNode != nullptr) 
    { 
     Node* tempNode = new Node; 
     tempNode->key = sourceNode->key; 
     tempNode->value = sourceNode->value; 
     targetNode->next = tempNode; 
     targetNode = targetNode->next; 
     sourceNode = sourceNode->next; 

    } 

    targetNode->next = nullptr; 

} 



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

    for (int i = 0; i < arrysz; i++) 
    { 
     if (source[i] != nullptr) 
     { 

      Node* copy = new Node; 
      copyNode(source[i], copy); 
      target[i] = copy; 
     } 

     else 
     { 
      target[i] = nullptr; 
     } 
    } 


} 

void HashMap::deleteLinkedList(Node* node) 
{ 




    while (node != nullptr) 
    { 
     if (node->next == nullptr) 
     { 
      delete node; 
      break; 

     } 

     else 
     { 
      Node* next = node->next; 
      delete node; 
      node = next; 
     } 
    } 

} 

// Adds node to the end of linked list 

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

    } 

} 

Когда я побежал MemCheck он сказал, что ошибка в функции deleteLinkedList, в этой строке:

if (node->next == nullptr) 

Поскольку проблема возникает только при повторном подключении, я был более склонен проверять функцию повторной записи, однако функция перефразирования работает нормально, если я не вызываю перегруженный метод оператора присваивания. Я бы очень признателен за любую помощь.

спасибо.

Answer 1

В HashMap& HashMap::operator=(const HashMap& hm), вы забыли назначить this->currentBucketCount с hm.currentBucketCount перед вызовом arrayCopy.

Вы должны поменять оба утверждения и сохранить старое значение currentBucketCount назвать deleteLinkedList:

arrayCopy(hm.Buckets_Array, newNodeArray, currentBucketCount); 
    currentBucketCount = hm.currentBucketCount; 

быть заменен

int oldBucketCount = currentBucketCount; 
    currentBucketCount = hm.currentBucketCount; 
    arrayCopy(hm.Buckets_Array, newNodeArray, currentBucketCount); 
    ... 
    for (int i = 0; i < oldBucketCount; i++) 
    { 
     deleteLinkedList(Buckets_Array[i]); 
    } 

или

arrayCopy(hm.Buckets_Array, newNodeArray, hm.currentBucketCount); 
    // currentBucketCount = hm.currentBucketCount; 
    // sh = hm.sz; 
    for (int i = 0; i < currentBucketCount; i++) 
    { 
     deleteLinkedList(Buckets_Array[i]); 
    } 
    currentBucketCount = hm.currentBucketCount; 
    sh = hm.sz;