c++ - 我的 DoublyLinkedList 中的打印函数会创建重复项。 C++

Question

基本上，当我的列表中只插入一个 Player 对象时，我的打印函数将打印出内容。但是当我插入另一个对象时，它会添加它，但插入的第一个元素已被覆盖。我已经测试了我的插入和附加功能，但我不认为它与这些功能有关。我认为 print 函数是按列表中的节点数打印最后输入的 firstName、lastName、level 和 exp。这是我的代码:

Stats.cpp

#include "Stats.h"
#include <iostream>
#include "Validators.h"
using namespace std;

Validators validators2;

Stats::Stats()
{
    firstName = "";
    secondName = "";
    level = 0;
    experience = 0;
}
Stats::Stats(string firstName,string secondName, int level, int experience)
{
    firstName = firstName;
    secondName = secondName;
    level = level;
    experience = experience;

}
    string Stats :: getFirstName()
    {
        return firstName;
    }
    string Stats :: getSecondName()
    {
        return secondName;
    }
    int Stats :: getLevel()
    {
        return level;
    }
    int Stats :: getExperience()
    {
        return experience;
    }
    Stats Stats :: input()
    {
        string inputfirstName = "Please enter the First Name: ";
        firstName = validators2.getString(inputfirstName);
        string inputSecondName = "Please enter the Second Name: ";
        secondName = validators2.getString(inputSecondName);
        cout<< "Please enter the level: ";
        level = validators2.getNum();
        cout<< "Please enter the experience: ";
        experience = validators2.getNum();

        Stats s1(firstName,secondName,level,experience);
        return s1;

    }

主要

int main ()
{
//-------------------------------------------------------------------------------------------
//  Set up a linkedList and a iterator. 
//-------------------------------------------------------------------------------------------
    DoublyLinkedList<Stats> list;
    DoublyLinkedListIterator<Stats> itr = list.getIterator();
        list.Insert(itr,stats.input());
        list.print(itr);
}
//--------------------------------------------------------------------------------------------
//  Name:           DoublyLinkedList.h.
//  Description:    Header file for the use in DoublyLinkedList.cpp.
//                  A DoublyLinkedList is a dynamically growing datastructure and use's
//                  nodes and pointers in its structure.
//--------------------------------------------------------------------------------------------
#ifndef DOUBLYLINKEDLIST_H
#define DOUBLYLINKEDLIST_H

#include <iostream>
#include "Validators.h"
#include "Stats.h"

using namespace std;

Validators validators;
Stats stats;


//-------------------------------------------------------------------------------------------
//  Class Declarations.
//-------------------------------------------------------------------------------------------
template<class Datatype> class DoublyLinkedList;
template<class Datatype> class DoublyLinkedListNode; 
template<class Datatype> class DoublyLinkedListIterator;
//-------------------------------------------------------------------------------------------
//  Class:  DoublyLinkedList.
//-------------------------------------------------------------------------------------------
template <class Datatype>
class DoublyLinkedList
{   
public:
//-------------------------------------------------------------------------------------------
//  Member Vairables.
//-------------------------------------------------------------------------------------------
DoublyLinkedListNode<Datatype>* m_head;
DoublyLinkedListNode<Datatype>* m_tail;
int m_count;
//-------------------------------------------------------------------------------------------
//  Name:           Constructor.
//  Description:    Constructs the DoublyLinkedList.
//-------------------------------------------------------------------------------------------
DoublyLinkedList()
{
    //Sets m_head to a default value of 0.  m_head is the first node in the linkedList.
    m_head = 0;
    //Sets m_tail to a default value of 0.  m_tail is the last node in the linkedList.
    m_tail = 0;
    //Sets m_count to a default value of 0.  m_count is to count the elements in the linkedList.
    m_count = 0;
}
//-------------------------------------------------------------------------------------------
//  Name:           Destructor.
//  Description:    Deletes the DoublyLinkedList.
//-------------------------------------------------------------------------------------------
~DoublyLinkedList()
{
    //Temporary node pointer.
    DoublyLinkedListNode<Datatype>* itr = m_head;
    DoublyLinkedListNode<Datatype>* next = 0;

    while(itr != 0)
    {
        //Save the pointer to next node. 
        next = itr->m_next;
        //Delete the current node.
        delete itr;
        //Make the next node the current node.
        itr = next;
    }
}
int getCount()
{
return m_count;
}
// -------------------------------------------------------------------------------------
//  Name:           Append
//  Description:    This adds a node to the end of the list, then points to the newNode
//  Arguments:      p_data - The data to store in the new node.
//                  m_count is increased.
//  Return Value:   None.
// -------------------------------------------------------------------------------------
    void Append(Datatype p_data)
    {
        if(m_head == 0)
        {
            // create a new head node.
            m_head= m_tail= new DoublyLinkedListNode<Datatype>;
            m_head->m_data= p_data;
            m_head->m_next= 0;
            m_head->m_prev= 0;
        }
        else
        {
            // insert a new node after the tail and reset the tail.
            m_tail->InsertAfter(p_data);
            m_tail= m_tail->m_next;
        }
        m_count++;
    }

//-------------------------------------------------------------------------------------------
//  Name:           Print.
//  Description:    Prints the elements from the list along with its index.
//-------------------------------------------------------------------------------------------
    void Print(DoublyLinkedListIterator<Datatype> m_itr)
    {
        for(m_itr.Start();m_itr.Valid();m_itr.Forth())
        {
            cout << "------------------Player------------------\n";
            cout << "First Name:\t\t" << stats.getFirstName() << "\n";
            cout << "Second Name:\t\t" << stats.getSecondName() << "\n";
            cout << "Level:\t\t\t" << stats.getLevel() << "\n";
            cout << "Experience:\t\t" << stats.getExperience() << "\n";
            cout << "------------------------------------------\n";
        }
    }
// ----------------------------------------------------------------------------------------------------------------
//  Name:           Insert
//  Description:    Inserts data before the iterator, this works whether the iterator is backwards of forwards
//                  through the list.Inserts at the end of the list if iterator is invalid.
//  Arguments:      p_iterator: The iterator to insert before
//                  p_data: the data to insert
//  Return Value:   None.
// ----------------------------------------------------------------------------------------------------------------
    void Insert(DoublyLinkedListIterator<Datatype>& p_itr, Datatype p_data)
    {
        if(p_itr.m_node != 0)
        {
            // insert the data before the iterator
            p_itr.m_node->InsertBefore(p_data);

            //if the iterator was at the head of the list,
            //reset the head pointer
            if(p_itr.m_node == m_head)
            {
                m_head = m_head->m_prev;
            }
            // increment the count
            m_count++;
        }
        else
        {
            Append(p_data);
        }
    }

//-------------------------------------------------------------------------------------------
//  Name:           GetIterator
//  Description:    Generates an iterator pointing towards the current head node
//  Arguments:      None.
//  Return Value:   <Datatype> Iterator
//-------------------------------------------------------------------------------------------
    DoublyLinkedListIterator<Datatype> getIterator()
    {
        return DoublyLinkedListIterator<Datatype>(this, m_head);
    }
};
//-------------------------------------------------------------------------------------------
//  Class:  DoublyLinkedNode.
//-------------------------------------------------------------------------------------------
template<class Datatype>
class DoublyLinkedListNode
{
public:
//-------------------------------------------------------------------------------------------
//  Member Vairables.
//-------------------------------------------------------------------------------------------
    DoublyLinkedListNode<Datatype>* m_next;
    DoublyLinkedListNode<Datatype>* m_prev;
    Datatype m_data;

// ----------------------------------------------------------------
//  Name:           InsertAfter
//  Description:    This adds a node after the current node.
//  Arguments:      p_data - The data to store in the new node.
//  Return Value:   None.
// ----------------------------------------------------------------
    void InsertAfter(Datatype p_data)
    {
        //Create the new node.
        DoublyLinkedListNode<Datatype>* newNode= new DoublyLinkedListNode<Datatype>;
        newNode->m_data = p_data;
        // make the new node point to the next node.
        newNode->m_next = m_next;
        newNode->m_prev = this;

        // make the node before it, point to the new node.
        //if(m_next != 0)
        //m_next->m_prev= newNode;
        m_next = newNode;
    }
// ----------------------------------------------------------------
//  Name:           InsertBefore
//  Description:    This adds a node before the current node.
//  Arguments:      p_data - The data to store in the new node.
//  Return Value:   None.
// ----------------------------------------------------------------
    void InsertBefore(Datatype p_data)
    {
        //Create new Node
        DoublyLinkedListNode<Datatype>* newNode = new DoublyLinkedListNode<Datatype>;
        newNode->m_data = p_data;
        //Set up new Node Pointers
        newNode->m_next = this;
        newNode->m_prev = m_prev;
        //if theres a node before it, make it point to new node
        if(m_prev != 0)
        m_prev = newNode;
    }
};
//-------------------------------------------------------------------------------------------
//  Class:  DoublyLinkedIterator.
//-------------------------------------------------------------------------------------------
template <class Datatype>
class DoublyLinkedListIterator
{
public:
//-------------------------------------------------------------------------------------------
//  Member Vairables.
//-------------------------------------------------------------------------------------------
    DoublyLinkedListNode<Datatype>* m_node;
    DoublyLinkedList<Datatype>* m_list;
    DoublyLinkedListIterator(DoublyLinkedList<Datatype>* p_list= 0, DoublyLinkedListNode<Datatype>* p_node= 0)
    {
        m_list= p_list;
        m_node= p_node;
    }

// ------------------------------------------------------------------
//  Name:           Start
//  Description:    Resets the iterator to the beginning of the list.
//  Arguments:      None.
//  Return Value:   None.
// ------------------------------------------------------------------
    void Start()
    {
        if(m_list!= 0)
            m_node= m_list -> m_head;
    }

// ----------------------------------------------------------------
//  Name:           End
//  Description:    Resets the iterator to the end of the list
//  Arguments:      None.
//  Return Value:   None.
// ----------------------------------------------------------------
    void End()
    {
        if(m_list!= 0)
            m_node = m_list->m_tail;
    }

// ----------------------------------------------------------------
//  Name:           Forth
//  Description:    Moves the iterator forward by one position
//  Arguments:      None.
//  Return Value:   None.
// ----------------------------------------------------------------
    void Forth()
    {
        if(m_node != 0)
        {
        m_node = m_node ->m_next;
        }
    }

// ----------------------------------------------------------------
//  Name:           Back
//  Description:    Moves the iterator backward by one position.
//  Arguments:      None.
//  Return Value:   None.
// ----------------------------------------------------------------
    void Back()
    {
        if(m_node!= 0)
            m_node = m_node->m_prev;
    }


// ----------------------------------------------------------------
//  Name:           Item
//  Description:    Gets the item that the iterator is pointing to.
//  Arguments:      None.
//  Return Value:   Reference to the data in the node.
// ----------------------------------------------------------------
    Datatype& Item()
    {
        return m_node->m_data;
    }
//-----------------------------------------------------------------
//  Name:           Valid
//  Description:    Determines if the node is valid.
//  Arguments:      None.
//  Return Value:   true if valid
// ----------------------------------------------------------------
    bool Valid()
    {
        return (m_node!= 0);
    }
};




#endif

Answer 1

你的打印循环看起来应该是这样的

   for(m_itr.Start();m_itr.Valid();m_itr.Forth())
    {
        cout << "------------------Player------------------\n";
        cout << "First Name:\t\t" << m_itr.Item().getFirstName() << "\n";
        cout << "Second Name:\t\t" << m_itr.Item().getSecondName() << "\n";
        cout << "Level:\t\t\t" << m_itr.Item().getLevel() << "\n";
        cout << "Experience:\t\t" << m_itr.Item().getExperience() << "\n";
        cout << "------------------------------------------\n";
    }

看看它如何使用迭代器获取要打印的值。