c++ - 控制台崩溃，无法识别错误？

Question

它实际上在控制台中显示了正确的消息，但随后几乎立即崩溃。

#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");
}   

任何对我的风格的评论也将不胜感激。这有点让我发疯，我快到了......

Answer 1

第一个错误。您忘记在复制构造函数中初始化成员变量:

template <typename T>
LinkedL<T>::LinkedL(const LinkedL<T>& rhs):m_First(nullptr),m_Last(nullptr),m_Size(0)
{
    *this = rhs;
}

第二个错误，您正在初始化并再次递增 m_Size 变量。评论如下:

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

完整的代码。享受:

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

template <typename T>
Node<T>* Node<T>::getNext() const {
    return m_Next;
}

template <typename T>
Node<T>* Node<T>::getPrev() const {
    return m_Prev;
}

template <typename T>
void Node<T>::setNext(Node<T>* n) {
    m_Next = n;
}

template <typename T>
void Node<T>::setPrev(Node<T>* p) {
    m_Prev = p;
}

template <typename T>
void Node<T>::setData(const T& data) {
    m_Data = data;
}

template <typename T>
T Node<T>::getData() {
    return m_Data;
}

#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()
{
    destroy();
}

template <typename T>
LinkedL<T>::LinkedL(const LinkedL<T>& rhs):m_First(nullptr),m_Last(nullptr),m_Size(0)
{
    *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>
bool LinkedL<T>::isEmpty() {
    if (m_First == nullptr) {
        return true;
    } return false; 
}

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>::insertAfter(const T& key, const T& data) {
    if (isEmpty()) {
        return;
    } 
    Node<T>* current=0;
    for (int i = 0; i < this->getSize(); i++) {
        if (this->operator[](i) == key) {
            current = this->getNode(i);
        }
    }
    Node<T>* newNode = new Node<T>(data);
    if (current == 0) {
        cout << "Node could not be found." << endl;
        return;
    }
    else if (current==m_Last) {
        m_Last = newNode;
        newNode->setNext(nullptr);
    }
    else {
        current->getNext()->setPrev(newNode);
        newNode->setNext(current->getNext());
    }
    current->setNext(newNode);
    newNode->setPrev(current);
    m_Size++;
}

template <typename T>
int LinkedL<T>::getSize() const{
    return 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");
}