-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'的实际大小。 –