-1
我正在實現一個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)
由於問題只發生在重新散列發生時，我更傾向於檢查重新散列函數，但是如果我不調用賦值運算符重載方法，則散列函數可以正常工作。我真的很感激任何幫助。
謝謝。
關上更換， 'hm.Buckets_Array'的大小是'hm.currentBucketCount'，但你傳遞'this-> currentBuck etCount'（我猜這可能會不同）到'arrayCopy'。同樣，調用'deleteLinkedList（）'的循環運行'hm.currentBucketCount'次，這可能不等於'this-> Buckets_Array'的實際大小。 –