队列和链表c ++的访问冲突错误

Question

我有一个作业，它是建立一个队列链表。

我们的教授给了我们骨架并告诉我们使用他的主骨。

我编写了我的函数和编译好的所有东西，但是当我运行它时，我收到了这个错误。

不知道该怎么做。

源代码：

                #include<iostream>
    using namespace std;

    template<class ItemType>
    struct NodeType
    { 
            ItemType info;
            NodeType* next;
    };

    template<class ItemType>
    class Queue
    { 
            private:
                int size;
                NodeType<ItemType>* front;  // It points to the front of a singly-linked list
                NodeType<ItemType>* rear;   // It points to the end of a singly-linked list

            public:
                Queue();                    // default constructor: Queue is created and empty
                Queue(const Queue<ItemType> &x);  // copy constructor: implicitly called 
                                                    // for a deep copy
                void MakeEmpty();    // Queue is made empty; you should deallocate all 
                                                    //  the nodes of the linked list
                bool IsEmpty( );   // test if the queue is empty
                bool IsFull( );   // test if the queue is full; assume MAXITEM=5
                int length( );    // return the number of elements in the queue
                void Print( );   // print the value of all elements in the queue in the sequence 
                                    // from the front to rear
                void Enqueue(ItemType x);   // insert x to the rear of the queue  
                                                // Precondition: the queue is not full
                void Dequeue(ItemType &x);  // delete the element from the front of the queue
                                                // Precondition: the queue is not empty
                ~Queue();  // Destructor:  memory for the dynamic array needs to be deallocated
    };

    template<class ItemType>
    Queue<ItemType>::Queue()
    {
        size = 0;
        front = NULL;
        rear = NULL;
    }

    template<class ItemType>
    Queue<ItemType>::Queue(const Queue<ItemType> &x)
    {
            NodeType<ItemType>* ptr1 ;
            NodeType<ItemType>* ptr2 ;

            if ( x.front == NULL )
            {
                front = NULL ;
            }

            else // allocate memory for first node
            {
                front = new NodeType<ItemType> ;
                front->info = x.front->info ;
                ptr1 = x.front->next ;
                ptr2 = front ;
            while ( ptr1 != NULL ) // deep copy other nodes
            { 
                ptr2->next = new NodeType<ItemType> ;
                ptr2 = ptr2->next ;
                ptr2->info = ptr1->info ;
                ptr1 = ptr1->next ;
            }

            ptr2->next = NULL;
            rear = ptr2;
            }

    }

    template<class ItemType>
    void Queue<ItemType>::MakeEmpty()
    {
        NodeType<ItemType>* tempPtr;
        while(front != NULL) 
        {
            tempPtr = front;
            front = front->next;
            delete tempPtr;
        }
        rear=NULL;
    }

    template<class ItemType>
    bool Queue<ItemType>::IsEmpty()
    {
        return (size == 0);
    }

    template<class ItemType>
    bool Queue<ItemType>::IsFull()
    {
        return (size >= 5);
    }

    template<class ItemType>
    int Queue<ItemType>::length()
    {
        return size;
    }

    template<class ItemType>
    void Queue<ItemType>::Enqueue(ItemType x)
    {
        NodeType<ItemType>* newNode;
        newNode = new NodeType<ItemType>;

        newNode->info = x;
        newNode->next = NULL;

        if(rear == NULL) 
        {
            front = newNode;
        }
        else
        {
            rear->next = newNode;
            rear = newNode;
        }


        size++;

    }

    template<class ItemType>
    void Queue<ItemType>::Dequeue(ItemType &x)
    {
        NodeType<ItemType>* tempPtr;

        if(!IsEmpty())
        {
        tempPtr = front;
        x = front->info;
        front = front->next;
        if(front == NULL) 
        {
            rear = NULL;
        }
        delete tempPtr;
        }

        size--;
    }

    template<class ItemType>
    void Queue<ItemType>::Print()
    {
        NodeType<ItemType> *temp;
        temp = rear;
        while(temp != NULL)
        {
            cout<<temp->info<<endl;
            temp = temp->next;
        }

    }

    template<class ItemType>
    Queue<ItemType>::~Queue()
    {
        MakeEmpty();
    }

    int main()
    {
        Queue<int>IntQueue;
        int x;
        IntQueue.MakeEmpty();
        IntQueue.Dequeue(x);
        IntQueue.Enqueue(10);
        IntQueue.Enqueue(20);
        IntQueue.Enqueue(30);
        IntQueue.Enqueue(40);
        cout << "int length 3 = " << IntQueue.length() << endl;
        IntQueue.Dequeue(x);
        cout << "int length 4 = " << IntQueue.length() << endl;
        cout << "The int queue contains:  " << endl;
        IntQueue.Print();
        if(IntQueue.IsFull() == false)
        cout << "The int queue is not full !" << endl;
        else
        cout << "The int queue is full !" << endl;

        Queue<float>FloatQueue;
        float y;
        FloatQueue.MakeEmpty();
        FloatQueue.Dequeue(y);
        FloatQueue.Enqueue(7.1);
        cout << "float length 3 = " << FloatQueue.length() << endl;
        FloatQueue.Enqueue(2.3);
        cout << "float length 4 = " << FloatQueue.length() << endl;
        FloatQueue.Enqueue(3.1);
        FloatQueue.Dequeue(y);
        cout << "The float queue contains:  " << endl;
        FloatQueue.Print();
        Queue<float> FloatQueue2 = FloatQueue;
        cout << "The float queue 2 contains:  " << endl;
        FloatQueue2.Print();
        FloatQueue.MakeEmpty();
        cout << "The float queue 3 contains:  " << endl;
        FloatQueue2.Print();

        system("pause");
        return 0;
    }

我遇到的问题显然是打印功能。

感谢任何帮助。

Answer 1

在您的复制构造函数中，您rear时没有将x.front == NULL设置为任何内容。这会将temp设置为Print内的无效值，导致您不应该循环，并取消引用无效指针。