C++ 自定义哈希表的使用给出了 SegFault

Question

I had to implement a Linked HashTable for a project. Now I have to come up with an excercise and a solution to it using my hashtable. Everything works just fine, except I get random Segfault errors.

By Random I mean: It is the same line of code that causes it, but always at different times, calls. I tested my code in Atom, Codeblocks and in Visual Studio Code. Both Atom and CB threw SegFault error, but VS Code ran it just fine without a problem.

NOTE: THIS IS NOT THE FULL/REAL CODE. It's part of a header file that is included in the main.cpp file which is then compiled and ran. The Code:

#include <iostream>
#include <typeinfo>
#include <string>

using namespace std;

//List:
template<class T>
struct Node
{
  string data;
  Node *next;
};

class List
{
  private:
    Node *head, *tail;
    int length;
    friend class HashTable;
  public:
    List();
    List(const List &L);
    //~List() {delete this;};
    List& operator =(List L);
    int find(string);
    void insert(string value);
    void remove_head();
    void remove_poz(int);
    void remove_tail();
    void clear();
    void display();
};

List::List()
{
   head = NULL;
   tail = NULL;
   length = 0;
}

template<>
string List<string>::findByIndex(int ind)
{
    int i = 0;
    Node<string>* temp = new Node<string>;
    temp = head;
    while (temp != NULL)
    {
        i++;
        if (i == ind) return temp->data;
        temp = temp->next;
    }
    delete temp;
    return "-1";
}

template<class T>
void List<T>::remove_head()
{
  Node<T>* temp = new Node<T>;
  temp = head;
  head = head->next;
  delete temp;
  length--;
}

template<class T>
void List<T>::remove_pos(int pos)
{
  int i;
  Node<T>* curr = new Node<T>;
  Node<T>* prev = new Node<T>;
  curr = head;
  for (i = 1; i < pos; ++i)
  {
      prev = curr;
      curr = curr->next;
  }
  if (curr)
  {
    prev->next = curr->next;
    length--;
  }
  else cout << "Error" << endl;
}

template<class T>
void List<T>::remove_tail()
{
  Node<T>* curr = new Node<T>;
  Node<T>* prev = new Node<T>;
  curr = head;
  while (curr->next != NULL)
  {
      prev = curr;
      curr = curr->next;
  }
  tail = prev;
  prev->next = NULL;
  delete curr;
  length--;
}

//HashTable:
class HashTable
{
  private:
    List *table;
    float load, stored;
    int slots;
    friend class List;
  public:
    HashTable();
    HashTable(int);
    ~HashTable();
    int hashFunc(string key);
    int findTable(string);
    int findList(string);
    HashTable& operator =(const HashTable&);
    void resize();    //I need this one
    void insert(string);
    void remove(string);
    void clear(int);
    void clear();
    void display();
};

HashTable::HashTable()
{
  stored = 0;
  load = 0.00;
  slots = 15;
  table = new List[slots];
}

int HashTable::hashFunc(string key)
{
  int g, h = 0;
    unsigned int i;
    for (i = 0; i < key.size(); ++i)
    {
        h = (h << 4) + (int)(key[i]);
        g = h & 0xF0000000L;
        if (g != 0)
        {
            h = h ^ (g >> 24);
        }
        h = h & ~g;
    }
    return h % slots;
}

template<class T>
void HashTable<T>::remove(T value)
{
  int ind = hashFunc(value);
  int findInd = table[ind].findByValue(value);


  if (findInd == 0)
      table[ind].remove_head();

  else if (findInd < table[ind].length)
      table[ind].remove_pos(findInd);

  else table[ind].remove_tail();

  if (table[ind].isEmpty()) occupied--;
  stored--;
  load = stored / slots;
}

The function that would cause the segfault: (This would be called over and over again in a loop till I don't have more elements in my table)

string reakcio(HashTable<string>& HT, int tarolok)
{
    const int anyagszam = rand() % 4 + 2; //Min 2, Max 5 anyag hasznalodik
    int i = 0, j;
    string anyagok[5];
    string eredmeny;

    for(j = 0; j < tarolok && i < anyagszam; ++j) //elemek kivetele
    {
        while(!HT.table[j].isEmpty())
        {
            anyagok[i++] = HT.table[j].findByIndex(1); //This line right here is the culprit :(
            HT.remove(anyagok[i-1]);
        }
    }

    const int siker = rand() % 4 + 0; //75% esely a sikerre
    if (siker)
    {
        eredmeny = anyagok[0];
        for(i = 1; i < anyagszam; ++i)
            eredmeny += " + " + anyagok[i];
    }
    else
        eredmeny = "Sikertelen reakcio";
    return eredmeny;
}

(Note: only the functions that might be needed are shown here)

Every element of my hashtable, or of my lists is a 10 character long random string value. srand(time(NULL)) is used before the function call in main.cpp

Any help or advice would be much appreciated, as I'm stuck at this and I really need to move on to the next portion of my exercise, but I can't without this.

The main.cpp file:

#include <iostream>
//#include "LinkedHash.h"
#include "functions.cpp"

int main()
{
  HashTable<string> Anyagok;
  int tarolok;

  tarol(Anyagok); //Stores the data from file, no problem here, functions.cpp
  tarolok = Anyagok.getSlots();

  srand(time(NULL));
  int i = 1;
  while (Anyagok.getStored() > 5 )
    cout<<reakcio(Anyagok, tarolok)<<" "<<i++<<endl;

  return 0;
}

The LinkedHash.h contains the hashtable and the list, the functions.cpp contains the problematic function.

EDIT: By suggestion I changed out the

Node<string>* temp = new Node<string>;
temp = head;

part to

Node<string>* temp = head;

Also removed the delete line. But my problem is still the same:/

Answer 1

Everything works just fine, except I get random Segfault errors

Then nothing works at all.

A first review show little care to the cornercases in the list class. You need to define a correct behavior for

• operation on empty lists
• operation on first and last element
• key not found during search

Notable errors found:

• remove_head, remove_tail will segfault on empty list. head is NULL. head->next is invalid memory access. Similar errors are all over the implementation.
• HashTable<T>::remove(T value) will always remove something. Even if the value argument is not in the hashtable. This is deeply flawed
• findByIndex returning "-1" make no sense. "-1" is a valid input.
• Node<T>* temp = new Node<T>;temp = head; . You just leaked memory. You need a pointer to manipulate node addresses . You should not instantiate Nodes to get a pointer. This is not an issue (ie not noticeable) for a small projet, but unacceptable for a real implementation.