C++ C++；哈希表上的ADT集实现（使用独立列表解决冲突）

正如标题所说，我试图在具有独立列表的哈希表上实现SETADT。问题是我不知道我错在哪里

我将要发布的代码来自一个更大的项目，我只是将其中重要的部分展示给大家

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;
}

#pragma一次
#布拉格语一次
#包括
#定义容量10
使用名称空间std；
模板
类迭代器集；
模板
类集{
班级点头{
公众：
远程通讯元件；
点头，下一步；
};
公众：
Set（）；
无效添加（远程通信元素）；
int size（）；
void-sterge（远程通讯元件）；
bool-cauta（远程医疗元件）；
友元类迭代器集；
迭代器集迭代器（）{返回迭代器集（this）；}
私人：
内部尺寸；
字体名称集：：Nod*prim；
int max；
Nod**表；
int hashFunction（TElement元素）{return element.hashCode（）%max；}
Nod*set；
};
模板
Set：：Set（）
{
最大值=电容；
表=新节点*[max]；
对于（int i=0；ielement））
当前=当前->下一步；
如果（当前！=NULL）
返回；
其他的
{
Nod*n=新节点；
n->element=元素；
n->next=表[pozitie]；
表[pozitie]=n；
}
dimensune++；
}
模板
int Set:：size（）
{
返回维度；
}
模板
void Set:：sterge（远程元素）
{
int pozitie=hashFunction（元素）；
Nod*curent=表[pozitie]；
if（表[pozitie]==NULL）
返回；
if（表[pozitie]->element==element）
{
Nod*deSters=表[pozitie]；
表[pozitie]=表[pozitie]->下一步；
删除dester；
尺寸--；
返回；
}
Nod*elem=表[pozitie]；
而（元素->下一步！=NULL&&（元素->下一步->元素）==element）
元素=元素->下一步；
如果（元素->下一步！=NULL）
{
Nod*deSters=elem->next；
元素->下一步=元素->下一步->下一步；
删除dester；
尺寸--；
}
}
模板
布尔集合：：cauta（远程通讯元件）
{
int pozitie=hashFunction（元素）；
Nod*curent=表[pozitie]；
while（curent！=NULL&&！（element==curent->element））
当前=当前->下一步；
如果（当前！=NULL）
{
返回true；
}
返回false；
}
模板
类迭代器集{
公众：
迭代器集（Set*m）；
下一步无效（）；
bool-valid（）；
远程通讯元件（）；
私人：
集合*集合；
字体名称：Nod*crt；
};
模板
迭代器集：：迭代器集（Set*mul）{
Set=mul；
crt=mul->prim；
}
模板
bool迭代器集：：valid（）{
返回crt！=NULL；
}
模板
TElement迭代器集：：元素（）{
返回crt->element；
}
模板
void迭代器集：：next（）{
crt=crt->next；
}

======================================================= domain.h（比萨饼的名称）

#包括
使用名称空间std；
高级披萨{
公众：
披萨（字符串名称披萨）：名称披萨（名称披萨）{}
Pizza（）：名称Pizza（“”{}
字符串getName（）常量{
返回披萨；
}
int hashCode（）
{
整数和=0；
for（无符号i=0；i

==================================================== 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;
}

#包括“SetADT.h”
#包括
#包括
#包括“domain.h”
无效显示（设置*设置）{
迭代器设置it=set->iterator（）；
while（it.valid（））{
cout原因可能是，例如，您在迭代器中使用的
prim
变量被初始化为未定义的值。但是，您发布的代码是不可编译的，也就是说，您的代码无法工作还有其他问题。您没有下载zip文件。
我真的希望哈希表是exerc的一个要点ise，或者你应该使用标准库hashmap类。是的。这正是我必须要做的任务。他们不会让我使用无序的\u map或无序的\u SetZIP文件编译，问题是更好的例子。你能发布你工作代码的plz相关要点吗，否则很难帮助）
#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;
}