0
Es zeigt tatsächlich die richtige Nachricht in der Konsole an, stürzt dann aber fast sofort ab.Konsole stürzt ab, Fehler kann noch nicht erkannt werden?
#ifndef NODE_H
#define NODE_H
template <typename T>
class Node
{
private:
T m_Data;
Node<T>* m_Next;
Node<T>* m_Prev;
public:
Node();
Node(const T& m_Data);
Node(const Node<T>& rhs);
~Node();
Node<T>* getNext() const;
Node<T>* getPrev() const;
Node<T>& operator=(const Node<T>& rhs);
T getData();
void destroy();
void setNext(Node<T>* n);
void setPrev(Node<T>* p);
void setData(const T& data);
};
template <typename T>
Node<T>::Node()
{
m_Data = T();
m_Next = nullptr;
m_Prev = nullptr;
}
template <typename T>
Node<T>::Node(const Node<T>& rhs) {
*this = rhs;
}
template <typename T>
Node<T>& Node<T>::operator=(const Node<T>& n) {
if (this == &n) {
return *this;
}
delete this;
Node<T> tmp = new Node<T>(n.m_Data);
tmp.setNext(n.getNext());
tmp.setPrev(n.getPrev());
*this = tmp;
return *this;
}
template <typename T>
Node<T>::Node(const T& data)
{
m_Data = data;
m_Next = nullptr;
m_Prev = nullptr;
}
template <typename T>
Node<T>::~Node()
{
setNext(nullptr);
setPrev(nullptr);
}
template <typename T>
void Node<T>::destroy()
{
m_Data = T();
setNext(nullptr);
setPrev(nullptr);
}
#endif
#ifndef LINKEDLIST_H
#define LINKEDLIST_H
#include "Node.h"
#include <iostream>
using namespace std;
template <typename T>
class LinkedL
{
public:
LinkedL();
~LinkedL();
LinkedL(const LinkedL<T>& rhs);
LinkedL<T>& operator=(const LinkedL<T>& rhs);
void insertFirst(const T& data);
void insertLast(const T& data);
void insertAfter(const T& key, const T& data);
void destroy();
bool isEmpty();
int getSize()const;
bool remove(int i);
void traverseForward();
T operator[](int i);
private:
Node<T>* getNode(int i) const;
Node<T>* m_First;
Node<T>* m_Last;
int m_Size;
};
template <typename T>
LinkedL<T>::LinkedL()
{
m_First = nullptr;
m_Last = nullptr;
m_Size = 0;
}
template <typename T>
LinkedL<T>::LinkedL(const LinkedL<T>& rhs) {
*this = rhs;
}
template <typename T>
LinkedL<T>& LinkedL<T>::operator=(const LinkedL<T>& rhs) {
if (this == &rhs) {
return *this;
}
destroy();
m_Size = rhs.m_Size;
Node<T>* head = new Node<T>(rhs.m_First->getData());
insertFirst(head->getData());
Node<T>* current = rhs.m_First->getNext();
while (current != nullptr) {
insertLast(current->getData());
current = current->getNext();
}
return *this;
}
template <typename T>
void LinkedL<T>::destroy() {
if (m_First != nullptr) {
Node<T>* current = m_First;
while (current != nullptr) {
Node<T>* oldNode = current;
current = current->getNext();
delete oldNode;
oldNode = 0;
}
}
}
template <typename T>
void LinkedL<T>::insertFirst(const T& data) {
Node<T>* newNode = new Node<T>(data);
if (isEmpty()) {
m_First = newNode;
m_Last = newNode;
}
else {
m_First->setPrev(newNode);
newNode->setNext(m_First);
m_First = newNode;
}
m_Size++;
}
template <typename T>
void LinkedL<T>::insertLast(const T& data) {
Node<T>* newNode = new Node<T>(data);
if (isEmpty()) {
m_Last = newNode;
m_First = newNode;
}
else {
m_Last->setNext(newNode);
newNode->setPrev(m_Last);
m_Last = newNode;
}
m_Size++;
}
template <typename T>
T LinkedL<T>::operator[](int i) {
int counter = 0;
Node<T>* current = m_First;
while (true) {
if (counter == i) {
return (current->getData());
}
current = current->getNext();
counter++;
}
}
template <typename T>
Node<T>* LinkedL<T>::getNode(int i) const{
int counter = 0;
Node<T>* current = m_First;
if (i<0 && i>=this->getSize()) {
return nullptr;
}
while (true) {
if (counter == i) {
return current;
}
current = current->getNext();
counter++;
}
}
template <typename T>
bool LinkedL<T>::remove(int i) {
if (isEmpty() || i<0 || i>=getSize()) {
cout << "No nodes to remove in specified index" << endl;
return false;
}
Node<T>* iNode = getNode(i);
if (getSize()==1) { //only 1 element in the list
m_Last = iNode->getNext();
m_First = nullptr;
delete iNode;
}
else if (i==0) { //remove first element
Node<T>* next = getNode(i + 1);
next->setPrev(nullptr);
m_First = next;
delete iNode;
}
else if(i==(getSize()-1)){//remove last element
Node<T>* prev = getNode(i - 1);
prev->setNext(nullptr);
m_Last = prev;
delete iNode;
}
else { //remove "sandwiched" element
Node<T>* prev = getNode(i - 1);
Node<T>* next = getNode(i + 1);
prev->setNext(next);
next->setPrev(prev);
delete iNode;
}
m_Size--;
return true;
}
template <typename T>
void LinkedL<T>::traverseForward() {
for (int i = 0; i < getSize(); i++) {
cout << "[" << i << "] " << this->operator[](i) << " ";
}
}
#endif // !LINKEDLIST_H
#include <iostream>
#include "LinkedL.h"
#include "Node.h"
using std::cout;
using std::endl;
int main() {
LinkedL<int> list;
list.insertFirst(31);
list.insertLast(23);
list.insertAfter(23, 67);
list.insertAfter(23, 45);
LinkedL<int> list1(list);
list.destroy();
list1.traverseForward();
system("PAUSE");
}
Alle Kommentare zu meinem Stil auch sehr geschätzt würden. Es macht mich irgendwie verrückt und ich bin fast da ...
Das ist eine Menge Code zu durchlaufen, um irgendwelche Fehler zu finden, die Sie haben könnten. Bitte veröffentlichen Sie ein [minimales, vollständiges und überprüfbares Beispiel] (http://stackoverflow.com/help/mcve). –
Sie müssen 'getNode' nicht in' remove' verwenden, da Sie den vorherigen und nächsten Knoten bereits kennen. Im schlimmsten Fall durchqueren Sie die Liste ~ 3 mal, nur um einen Knoten zu entfernen. – molbdnilo