对象向量中的内存访问冲突

Question

访问HashMap类的“put”方法时出现以下错误。我正在使用VS2008编译以下代码。

abc.exe中0x00eece26处的未处理异常：0xC0000005： 访问冲突读取位置0xfeeefefe。

在main函数中，我创建了一个HashMap对象的向量。当我尝试调用“HashMap”类的“put”方法时，它会给出上面提到的错误。 单个对象可以正常工作，但是对象向量会崩溃。有帮助吗？ 非常感谢。

我正在使用以下类定义

class HashMap 
{
private:
      int TABLE_SIZE;
      LinkedHashEntry **table;

public: 
      HashMap(void){}

      HashMap(int tableSize) 
      {
            TABLE_SIZE = tableSize;
            table = new LinkedHashEntry*[TABLE_SIZE];
            for (int i = 0; i < TABLE_SIZE; i++)
                  table[i] = nullptr;
      }


      double get(int key) 
      {
            int hash = (key % TABLE_SIZE);       
            if (table[hash] == nullptr)
                  return -1;
            else 
            {
                  LinkedHashEntry *entry = table[hash];    
                  while (entry != nullptr && entry->getKey() != key)                     
                        entry = entry->getNext();

                  if (entry == nullptr)
                        return -1;
                  else                    
                        return entry->getValue();
            }
      }


      void put(int key, double value) 
      {
            int hash = (key % TABLE_SIZE);
            if (table[hash] == nullptr)
                  table[hash] = new LinkedHashEntry(key, value);
            else 
            {
                  LinkedHashEntry *entry = table[hash];   
                  while (entry->getNext() != nullptr)
                        entry = entry->getNext();

                  if (entry->getKey() == key)
                        entry->setValue(value);
                  else
                        entry->setNext(new LinkedHashEntry(key, value));
            }
      }     

  // ...
};

LinkedHashEntry的定义如下。

class LinkedHashEntry 
{
private:
  int key;
  double value;
  LinkedHashEntry *next;

public:
  LinkedHashEntry(int key, double value) {
        this->key   = key;
        this->value = value;
        this->next  = nullptr;
  }

  int getKey() {
        return key;
  }

  double getValue() {
        return value;
  }

  void setValue(double value) {
        this->value = value;
  }

  LinkedHashEntry *getNext() {
        return next;
  }

  void setNext(LinkedHashEntry *next) {
        this->next = next;
  }
};

这是我创建矢量数组的主要方法。

#include <vector>

int main()
{
    // ...

    // works fine here
    HashMap objTest(17);
    objTest.put(1,1.1);

    std::vector<HashMap> objHashTable(10, HashMap(17));          
    // crashes here 
    objHashTable[0].put(1, 1.1);

    // ...
}

Answer 1

代码似乎是一个活生生的内存泄漏和维护噩梦。

我无法从发布的代码中看到它崩溃，但两者都

    table = new LinkedHashEntry*[TABLE_SIZE];

和

    table[hash] = new LinkedHashEntry(key, value);

永远不会被释放。

我建议使用较少错误/易受攻击的类重写main：http://en.cppreference.com/w/cpp/container/unordered_map

#include <vector>
#include <unordered_map>

typedef std::unordered_map<int, double> HashMap;

static const int hashTableSize = 17;

int main()
{
    // works fine here
    HashMap objTest(hashTableSize);
    objTest[1] = 1.1; // or objTest.insert({ 1, 1.1 });

    std::vector<HashMap> objHashTable(10, HashMap(hashTableSize));

    // works fine here too
    objHashTable[0].insert({ 1, 1.1 });

    // ZEN achieved; no memory leaks
}

查看 live on Coliru