Программа Cra sh в итераторе двусвязного списка print на C ++

Question

Я пытаюсь запустить итератор связанного списка, чтобы напечатать данные, которые я ввел в список. Ему удается распечатать все записи, но как только это происходит, программа вылетает. Кто-нибудь видит, что может быть причиной? Я запускаю его на CodeBlocks, поэтому я не знаю, может ли это быть проблемой.

Это тот же проект, с которым я имел дело в других моих вопросах. Прежде чем я попытался запустить итератор, чтобы распечатать содержимое функции внутри класса списка. Однако спецификации назначения не позволяют классам запускать какие-либо сообщения об ошибках или управлять сообщениями в отчете. Идеально для пользователя, чтобы получить полный доступ к данным. Все, что касается консольных сообщений, должно быть сделано в основном. Это то, что я получил после настройки. Опять же, он печатает содержимое списка успешно, но после этого программа перестает работать.

Код:

#include <iostream>
#include <string>

using namespace std;

typedef string dataType;
typedef class LISTEntry* listPtr;

class DATAClass
{
    dataType key;
public:
    DATAClass();
    DATAClass(dataType key);
    DATAClass(DATAClass &dc);

    void setKey(dataType keyVal);
    dataType getKey();
};

DATAClass::DATAClass() {
  key = key;
}

DATAClass::DATAClass(dataType key) {
  this->key = key;
}

DATAClass::DATAClass(DATAClass &dc) {
  key = dc.key;
}

void DATAClass::setKey(dataType keyVal) {
  key = keyVal;
}

dataType DATAClass::getKey() {
  return key;
}


class LISTEntry
{
  DATAClass data;
  listPtr prev;
  listPtr next;

public:
  LISTEntry() {
    this->data = data;
    this->prev = nullptr;
    this->next = nullptr;
    };

  LISTEntry(DATAClass l) {  
    this->data = l;
    this->prev = nullptr;
    this->next = nullptr;
    };

  LISTEntry(LISTEntry &le) {
    data = le.getData();
    prev = nullptr;
    next = nullptr;
    };

  ~LISTEntry() {
  };

  LISTEntry & operator=(const LISTEntry &le) {
    if (this != &le)
        {
            data = le.data;
            prev = nullptr;
            next = nullptr;
        }
    };

  LISTEntry * getNext() {
        return next;
    };

  void setNext(LISTEntry * entry) {
        next = entry;
    };

  LISTEntry * getPrev() {
        return prev;
    };

  void setPrev(LISTEntry * entry) {
        prev = entry;
    };

  DATAClass getData() {
        return data;
    };

  void setData(DATAClass d) {
        data = d;
    };
};


class LIST
{
private:
    listPtr curr;
    listPtr head;
    listPtr tail;

public:
    LIST();
    LIST(DATAClass d);
    LIST(LISTEntry l);
    LIST(LIST * l);
    ~LIST();

    void addList(dataType n);
    void iterateInitialize();
    bool iterate_hasNext();
    bool searchList(dataType key);

    LISTEntry * getHead();
    void setHead(LISTEntry * h);
    LISTEntry * getTail();
    void setTail(LISTEntry * t);
    LISTEntry * getCurr();
    void setCurr(LISTEntry * c);

    bool isEmpty();
    bool isFull();
};

LIST::LIST() {
    curr = nullptr;
    head = nullptr;
    tail = nullptr;
};

LIST::LIST(DATAClass d) {
    listPtr tmp;
    tmp->setData(d);
    tmp->getData();

    curr = tmp;
    head = nullptr;
    tail = nullptr;
};

LIST::LIST(LISTEntry l) {
    listPtr tmp;

    curr = tmp;
    head = tmp;
    tail = tmp;
};

LIST::LIST(LIST * l) {
    curr = nullptr;
    head = nullptr;
    tail = nullptr;
};

LIST::~LIST()
{}

void LIST::addList(dataType n) {
    DATAClass dc;
    dc.setKey(n);

    listPtr entry = new LISTEntry();
    entry->setData(dc);
    entry->setNext(nullptr);
    entry->setPrev(nullptr);

    if (!isEmpty())
    {
        tail->setNext(entry);
        entry->setPrev(tail);
        tail = entry;
        curr = tail;

        curr->setNext(nullptr);
        tail->setNext(nullptr);
    }

    else
    {
        head = tail = entry;
        head->setPrev(nullptr);
        tail->setNext(nullptr);

        curr = head;
    }
} //addList


void LIST::iterateInitialize() {
    setCurr(head);
}

bool LIST::iterate_hasNext() {
    return curr->getNext() != nullptr;
}

bool LIST::searchList(dataType key) {
    curr = head;
    while (curr != nullptr)
    {
        if (curr->getData().getKey() == key)
        {
            return true;
        }

        else
        {
            curr = curr->getNext();
        }
    }

    return false;
}

LISTEntry * LIST::getHead() {
    return head;
}

void LIST::setHead(LISTEntry * h) {
    head = h;
}

LISTEntry * LIST::getTail() {
    return tail;
}

void LIST::setTail(LISTEntry * t) {
    tail = t;
}

LISTEntry * LIST::getCurr() {
    return curr;
}

void LIST::setCurr(LISTEntry * c) {
    curr = c;
}

bool LIST::isEmpty() {
    return head == nullptr;
}

bool LIST::isFull() {
    return (new(LISTEntry) == nullptr);
}


int main()
{
    LIST * burger = new LIST();

    burger->addList("meat");
    burger->addList("pickles");
    burger->addList("onions");
    burger->addList("tomato");
    burger->addList("cheese");
    burger->addList("bun");

    burger->iterateInitialize();
    listPtr bgrIndex = burger->getCurr();

    while (burger->iterate_hasNext())
    {
        cout << bgrIndex->getData().getKey() << " ";
        bgrIndex = bgrIndex->getNext();

        if (!(burger->iterate_hasNext()))
            cout << endl;
    }

    dataType searchValue;
    while (searchValue != "end")
    {
        cout << "Enter an item to look up in the list: " << endl;
        cin >> searchValue;

        if (burger->searchList(searchValue))
            cout << "The item " << searchValue << " was found." << endl;

        else
            cout << "The item " << searchValue << " is not in the list." << endl;
    }

    delete burger;

    return 0;
}