列表2未在控制台上打印

代码应该打印出用户作为列表1输入的数字列表,告诉您列表有多长,让您搜索一个数字,然后删除一个数字。删除号码后,应将其保存到列表2中,然后打印出号码。代码一直运行到列表2。出于某种原因,列表1要么没有进入列表2,要么就是没有打印出列表2。如果能帮助我弄清楚为什么会发生这种情况,我将不胜感激。

主要的cpp公司

#include <iostream> 
#include "circularLinkedList.h"

using namespace std; 

void testCopyConstructor(circularLinkedList<int> oList);

int main()
{
    circularLinkedList<int> list1, list2;
    int num;

    cout << "Enter number ending with -999" << endl;
    cin >> num;

    while (num != -999)
    {
        list1.insertNode(num);
        cin >> num;
    }

    cout << endl;

    cout << "List 1: ";
    list1.print();
    cout << endl;

    cout << "Length List 1: " << list1.length() << endl;

    cout << "Enter the number to be searched:  ";
    cin >> num;
    cout << endl;

    if (list1.search(num))
        cout << num << " found in the list" << endl;
    else
        cout << num << " not in the list" << endl;

    cout << "Enter the number to be deleted: ";
    cin >> num;
    cout << endl;

    list1.deleteNode(num);

    cout << "After deleting the node, "
         << "List 1: ";
    list1.print();
    cout << endl;

    cout << "Length List 1: " << list1.length() << endl;

    list2 = list1;

    cout << "List 2: ";
    list2.print();
    cout << endl;

    cout << "Length List 2: " << list2.length() << endl;

    testCopyConstructor(list1);

    cout << "List 1: ";
    list1.print();
    cout << endl;

    return 0;
}

void testCopyConstructor(circularLinkedList<int> oList)
{
}

循环链接列表。h类

#ifndef H_circularLinkedList
#define H_circularLinkedList

#include <iostream>
#include <cassert> 
using namespace std;

template <class Type> 
struct nodeType
{
  Type info;
  nodeType<Type> *link;
};

template <class Type>
class circularLinkedList
{
public:
    const circularLinkedList<Type>& operator=
                      (const circularLinkedList<Type>&); 
    //Overloads the assignment operator.
    void initializeList(); 
    //Initializes the list to an empty state.
      //Postcondition: first = nullptr, last = nullptr,
    //                count = 0
    bool isEmptyList();
    //Function to determine whether the list is empty. 
    //Postcondition: Returns true if the list is empty;
    //               otherwise, returns false.

    void print() const;

  int length();
    //Function to return the number of nodes in the 
    //list.
    //Postcondition: The value of count is returned.
    void destroyList();
    //Function to delete all the nodes from the list.
      //Postcondition: first = nullptr, last = nullptr, 
    //               count = 0
    Type front(); 
    //Function to return the first element of the list.
    //Precondition: The list must exist and must not be
    //empty.
      //Postcondition: If the list is empty, then the 
    //               program terminates; otherwise, 
      //               the first element of the list is 
    //               returned.
    Type back(); 
       //Function to return the last element of the
       //list.
    //Precondition: The list must exist and must not
    //be empty.
    //Postcondition: If the list is empty, then the 
    //               program terminates; otherwise,
    //               the last element of the list is 
    //               returned.

  bool search(const Type& searchItem);
    //Function to determine whether searchItem is in 
    //the list.
    //Postcondition: Returns true if searchItem is found
    //               in the list; otherwise, it returns
    //               false.

    void insertNode(const Type& newitem);

    void deleteNode(const Type& deleteItem);
      //Function to delete deleteItem from the list.
    //Postcondition: If found, the node containing 
      //               deleteItem is deleted from the 
    //                list, first points to the first
    //                node, and last points to the last 
    //                node of the updated list. 

    circularLinkedList(); 
      //Default constructor
    //Initializes the list to an empty state.
    //Postcondition: first = nullptr, last = nullptr, 
    //               count = 0 

    circularLinkedList(const circularLinkedList<Type>& otherList); 
         //Copy constructor

    ~circularLinkedList();   
      //Destructor
      //Deletes all the nodes from the list.
      //Postcondition: The list object is destroyed. 

protected:
    int count;    //variable to store the number of 
          //elements in the list
    nodeType<Type> *first; //pointer to the first node of 
                           //the list
    nodeType<Type> *last;  //pointer to the last node of 
                           //the list 
private:
    void copyList(const circularLinkedList<Type>& otherList); 
    //Function to make a copy of otherList.
    //Postcondition: A copy of otherList is created 
    //               and assigned to this list.
};

template <class Type>
bool circularLinkedList<Type>::isEmptyList()
{
    return (first == NULL);
  // function to determine if list is empty
}

template <class Type>
circularLinkedList<Type>::circularLinkedList() // default constructor
{
  first = nullptr;
  count = 0;
}

template <class Type>
void circularLinkedList<Type>::destroyList()
{
      nodeType<Type> *temp;
        nodeType<Type> *current = NULL;

        if (first != NULL)
        {
            current = first->link;
            first->link = NULL;
        }

        while (current != NULL)
        {
            temp = current;
            current = current->link;
            delete temp;
        }

        first = NULL;   //initialize last to NULL; first has already
                        //been set to NULL by the while loop
        count = 0;
  // function to destroy the list
}


template <class Type>
void circularLinkedList<Type>::initializeList()
{
  destroyList(); //if the list has any nodes, delete them
}

template <class Type>
int circularLinkedList<Type>::length()
{
  return count;
  // function to find the length of the list
}  // end length

template <class Type>
Type circularLinkedList<Type>::front()
{   
    assert(first != nullptr);
    return first->link->info; //return the info of the first node 
}//end front


template <class Type>
Type circularLinkedList<Type>::back()
{   
    assert(first != nullptr);
    return first->info; //return the info of the first node 
}//end back

template <class Type>
bool circularLinkedList<Type>::search(const Type& searchItem)
{
      nodeType<Type> *current; //pointer to traverse the list
        bool found = false;

        if (first != NULL)
        {
            current = first->link;

            while (current != first && !found)
            {
                if (current->info >= searchItem)
                    found = true;
                else
                    current = current->link;

                found = (current->info == searchItem);
            }
        }

        return found;
    }
    // function to search the list for a given item
//end search

template <class Type>
void circularLinkedList<Type>::insertNode(const Type& newitem)
{
      nodeType<Type> *current; //pointer to traverse the list
        nodeType<Type> *trailCurrent; //pointer just before current
        nodeType<Type> *newNode;  //pointer to create a node

        bool  found;

        newNode = new nodeType<Type>; //create the node

        newNode->info = newitem;   //store newitem in the node
        newNode->link = NULL;      //set the link field of the node
                                   //to NULL

        if (first == NULL)  //Case 1    e.g., 3
        {
            first = newNode;
            first->link = newNode;
            count++;
        }
        else
        {
            if (newitem >= first->info)//e.g., 25 > 3
            {
                newNode->link = first->link;
                first->link = newNode;
                first = newNode;
            }
            else
            {
                trailCurrent = first; //e.g., 1 < 3
                current = first->link;
                found = false;

                while (current != first && !found)
                    if (current->info >= newitem)
                        found = true;
                    else
                    {
                        trailCurrent = current;
                        current = current->link;
                    }

                trailCurrent->link = newNode;
                newNode->link = current;
            }

            count++;
        }
  // function to insert an item into the list
}//end insertNode

template <class Type>
void circularLinkedList<Type>::deleteNode(const Type& deleteItem)
{
   nodeType<Type> *current; //pointer to traverse the list
        nodeType<Type> *trailCurrent; //pointer just before current
        bool found;

        if (first == NULL)    //Case 1; list is empty.
            cout << "Can not delete from an empty list." << endl;
        else
        {
            found = false;
            trailCurrent = first;
            current = first->link;

            while (current != first && !found)
                if (current->info >= deleteItem)
                    found = true;
                else
                {
                    trailCurrent = current;
                    current = current->link;
                }

            if (current == first)
            {
                if (first->info == deleteItem)
                {
                    if (first == first->link)
                        first = NULL;
                    else
                    {
                        trailCurrent->link = current->link;
                        first = trailCurrent;
                    }
                    delete current;

                    count--;
                }
                else
                    cout << "The item to be deleted is not in the list." << endl;
            }
            else
                if (current->info == deleteItem)
                {
                    trailCurrent->link = current->link;
                    count--;
                    delete current;
                }
                else
                    cout << "Item to be deleted is not in the list." << endl;
        } 
  // function to delete an item from the list
} //end deleteNode


  //Overloading the stream insertion operator
template <class Type>
void  circularLinkedList<Type>::print() const
{
    nodeType<Type> *current; //pointer to traverse the list

        current = first->link;

        while (current != first) //while more data to print
        {
            cout << current->info << " ";
            current = current->link;
        }

        cout << first->info << " ";
  // function to print the list
}

template <class Type>
circularLinkedList<Type>::~circularLinkedList() // destructor
{
  destroyList(); 
}//end destructor


template <class Type>
void circularLinkedList<Type>::copyList
                    (const circularLinkedList<Type>& otherList) 
{
        first = NULL;
        copyList(otherList);
   // function to copy the list
}//end copyList

  //copy constructor
template<class Type>
circularLinkedList<Type>::circularLinkedList
                    (const circularLinkedList<Type>& otherList) 
{
  first = nullptr;

  copyList(otherList);

}//end copy constructor

  //overload the assignment operator
template <class Type>
const circularLinkedList<Type>& circularLinkedList<Type>::operator=
          (const circularLinkedList<Type>& otherList)
{ 
  if (this != &otherList) //avoid self-copy
  {
    copyList(otherList);
  }//end else

  return *this; 
}

#endif