Question

当程序中的特定链接列表尝试调用析构函数时，出现读取访问冲突错误。我猜想它正在尝试销毁一个空列表，但是我的析构函数对此进行了检查，这只会在删除时导致违规。

错误来源

bool WaitOrders::loadOrderData()
{
    bool opened;
    int count, i = 0;
    ifstream fin(mOrderFilename);

    if (fin.is_open())
    {
        fin >> count;
        fin.ignore();

        while (!fin.eof() && i < count)
        {
            Order order;
            fin >> order;
            orders.insert(order); //<== insert function 
            i++;
        } // <== error happens here because of the Order object's linked list's destructor

        fin.close();
        opened = true;
    }
    else
    {
        opened = false;
    }

    return opened;
}

有关更多上下文，这是仅包含相关信息的“订单”类

class Order
{
private:
    const double TAX = 0.11;

    bool mStatus;
    int mOrderNum;
    double mFinalTotal, mSubTotal;
    Customer mCustomer;
    Table mTable;
    LL<Item> orderedItems;

public:
    // Constructors/Destructors

    Order();
    Order(int orderNum);
    Order(int orderNum, Table table);

    // Overloads

    void operator=(const Order& rhs);
    bool operator==(const Order& rhs);

    // Friend Functions

    friend std::ifstream& operator>>(std::ifstream& input, Order& obj);
    friend std::ostream& operator<<(std::ostream& output, Order& obj);
    friend std::ofstream& operator<<(std::ofstream& output, Order& obj);
};

如您所见，它有一个“ LL”，这是我制作的链接列表模板类。这是链接列表，或者至少是相关功能：

#include <iostream>
#include <fstream>
#include <string>

template <typename T>
class LL
{
    struct Node
    {
        T mData;
        Node *mNext;

        Node();
        Node(T data);
    };

private:
    Node *mHead, *mTail;
    int mCount;

public:
    // Constructors/Destructors

    LL();
    ~LL();

    // Functions

    void clear();
    bool insert(T data);

    // Overloads

    void operator=(const LL& rhs);

};

// Constructors/Destructors

template <typename T> LL<T>::Node::Node()
{
    mData;
    mNext = NULL;
}

template <typename T> LL<T>::Node::Node(T data)
{
    mData = data;
    mNext = NULL;
}

template <typename T> LL<T>::LL()
{
    mCount = 0;
    mHead = NULL;
    mTail = NULL;
}

template <typename T> LL<T>::~LL()
{
    clear();
}

// Functions

template <typename T> void LL<T>::clear()
{
    Node *tmp;
    tmp = mHead;

    while (mHead != NULL)
    {
        mHead = mHead->mNext;
        tmp->mNext = NULL;
        delete tmp; // <== THE EXACT LINE THAT CAUSES THE ERROR
        tmp = mHead;
    }

    mTail = NULL;
}

template <typename T> bool LL<T>::insert(T data)
{
    Node* newNode;
    newNode = new Node;

    if (newNode == NULL)
    {
        return false;
    }

    newNode->mData = data;

    if (mHead == NULL)
    {
        mHead = newNode;
    }
    else
    {
        mTail->mNext = newNode;
    }

    mTail = newNode;

    mCount++;

    return true;
}

// Overloads

template <typename T> void LL<T>::operator=(const LL& rhs)
{
    Node* tmp;

    tmp = rhs.mHead;

    if (rhs.mHead != NULL)
    {
        while (tmp != NULL)
        {
            insert(tmp->mData);
            tmp = tmp->mNext;
        }
    }
}

所以要注意的是，我的运算符“ =”的重载用于插入函数。由于它是两个Order对象，并且因为Order对象中有一个链表，所以我认为这可能是问题所在，因为我在此链表模板中使用的其他对象类型均未失败，因为他们自己有一个链表对象。只有我的Order类可以。

这是正在使用的Order类的运算符重载：

void Order::operator=(const Order& rhs)
{
    mOrderNum = rhs.mOrderNum;
    mStatus = rhs.mStatus;
    mSubTotal = rhs.mSubTotal;
    mFinalTotal = rhs.mFinalTotal;
    mCustomer = rhs.mCustomer;
    mTable = rhs.mTable;
    orderedItems = rhs.orderedItems; // <== The linked lists 
}

在最后一行中，我然后在链接列表中调用运算符重载“ =”，该操作符将所有数据从右侧“转移”到左侧。这可能是问题所在。

最后，当我从链接列表析构函数调用“ clear（）”函数时，正如我指出的那样，“删除tmp”行是发生错误的精确行。

我知道这是非常的路口，但是我正在经历调试的每个步骤，所以每个人都知道我从哪里来。请帮我。谢谢！

编辑：我已修复它！!!!

template <typename T> bool LL<T>::insert(T data)

必须将其更改为：

template <typename T> bool LL<T>::insert(T& data)

仅此而已。我觉得很傻。

导致读取访问冲突的链接列表析构函数

0 个答案: