C++ ADT Définir l'implémentation sur HashTable (résoudre des conflits avec des listes indépendantes)

Question

Comme le titre l'indique, j'essaie d'implémenter Set ADT sur un Hashtable avec des listes indépendantes. La chose est que je ne sais pas où je me trompe.

Le code que je suis sur le point de publier est tiré d'un plus grand projet et j'ai pris juste les parties essentielles de celui-ci pour vous montrer.

SetADT.h:

#pragma once 
#pragma once 
#include <stdio.h> 

#define CAPACITY 10 

using namespace std; 

template <typename TElement> 
class IteratorSet; 






template<typename TElement> 
class Set { 

    class Nod { 
    public: 
     TElement element; 
     Nod* next; 

    }; 

public: 

    Set(); 


    void add(TElement element); 


    int size(); 


    void sterge(TElement element); 


    bool cauta(TElement element); 


    friend class IteratorSet<TElement>; 
    IteratorSet<TElement> iterator() { return IteratorSet<TElement>(this); } 

private: 

    int dimensiune; 


    typename Set<TElement>::Nod* prim; 


    int max; 


    Nod** table; 


    int hashFunction(TElement element) { return element.hashCode() % max; } 


    Nod* set; 
}; 

template<typename TElement> 
Set<TElement>::Set() 

{ 
    max = CAPACITATE; 
    table = new Nod*[max]; 
    for (int i = 0; i < max; i++) 
     table[i] = NULL; 
} 

template <typename TElement> 
void Set<TElement>::add(TElement element) 

{ 
    int pozitie = hashFunction(element); 
    Nod* curent = table[pozitie]; 
    while (curent != NULL && !(element == curent->element)) 
     curent = curent->next; 
    if (curent != NULL) 
     return; 
    else 
    { 
     Nod* n = new Nod; 
     n->element = element; 
     n->next = table[pozitie]; 
     table[pozitie] = n; 
    } 
    dimensiune++; 
} 

template <typename TElement> 
int Set<TElement>::size() 

{ 
    return dimensiune; 
} 

template <typename TElement> 
void Set<TElement>::sterge(TElement element) 

{ 
    int pozitie = hashFunction(element); 
    Nod* curent = table[pozitie]; 


    if (table[pozitie] == NULL) 
     return; 


    if (table[pozitie]->element == element) 
    { 
     Nod* deSters = table[pozitie]; 
     table[pozitie] = table[pozitie]->next; 
     delete deSters; 
     dimensiune--; 
     return; 
    } 


    Nod* elem = table[pozitie]; 
    while (elem->next != NULL && (elem->next->element) == element) 
     elem = elem->next; 



    if (elem->next != NULL) 
    { 
     Nod* deSters = elem->next; 
     elem->next = elem->next->next; 
     delete deSters; 
     dimensiune--; 
    } 

} 

template <typename TElement> 
bool Set<TElement>::cauta(TElement element) 

{ 
    int pozitie = hashFunction(element); 
    Nod* curent = table[pozitie]; 
    while (curent != NULL && !(element == curent->element)) 
     curent = curent->next; 
    if (curent != NULL) 
    { 
     return true; 
    } 
    return false; 
} 







template<typename TElement> 
class IteratorSet { 
public: 
    IteratorSet(Set<TElement>* m); 
    void next(); 
    bool valid(); 
    TElement element(); 
private: 
    Set<TElement>* Set; 
    typename Set<TElement>::Nod* crt; 
}; 

template<typename TElement> 
IteratorSet<TElement>::IteratorSet(Set<TElement>* mul) { 
    Set = mul; 
    crt = mul->prim; 
} 

template<typename TElement> 
bool IteratorSet<TElement>::valid() { 
    return crt != NULL; 
} 

template<typename TElement> 
TElement IteratorSet<TElement>::element() { 
    return crt->element; 
} 

template<typename TElement> 
void IteratorSet<TElement>::next() { 
    crt = crt->next; 
} 

=================================== ==================== domain.h (noms des pizzas)

#include <string> 
using namespace std; 

class Pizza { 
public: 
    Pizza(string namePizza) : namePizza(namePizza) {} 
    Pizza() : namePizza("") {} 

    string getName() const { 
     return namePizza; 
    } 
    int hashCode() 
    { 
     int sum = 0; 
     for (unsigned i = 0; i < str.length(); i++) 
      sum += str[i]; 
     return sum; 
    } 
    bool operator == (Pizza& other) { 
     return namePizza == other.getName(); 
    } 

private: 
    string namePizza; 
    string str; 
}; 

============== ====================================== main.cpp:

#include "SetADT.h" 
#include <string> 
#include <iostream> 
#include "domain.h" 

void show(Set<Pizza>* set) { 
    IteratorSet<string> it = set->iterator(); 
    while (it.valid()) { 
     cout << "\t" << it.element().getName() << endl; 
     it.next(); 
    } 
} 



int main() 
{ 
    Set<Pizza> set; 

    Pizza pizza1{ "diavola" }; 
    Pizza pizza2{ "prosciuto" }; 

    set.add(pizza1); 
    set.add(pizza2); 

    show(set); 

    return 0; 
} 

Quand j'essaie d'imprimer t les objets ajoutés au Set It pops et erreur et le programme s'arrête.

Je ne connais nulle part ailleurs pour trouver le problème.

Quoi qu'il en soit, si l'exemple de code ne suffit pas, ici le projet complet (a des parties de roumanie en elle)

http://www20.zippyshare.com/v/qKpEcZhr/file.html

Answer 1

La raison peut être, par exemple, la variable prim que vous utilisez dans l'itérateur, initialisé à une valeur indéfinie. Toutefois, le code que vous avez publié n'est pas compilable, c'est-à-dire qu'il existe d'autres problèmes pour lesquels votre code ne fonctionne pas. Vous n'avez pas téléchargé votre fichier zip.