Question

我的程序的目的是读取文件中的数据并使用此数据构建链接列表，然后释放所有使用的节点。

程序还需要在创建节点后打印出节点的地址，然后删除它们

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

  #include "BigHero.h"

 using namespace std;

 // Linked List Struct
 struct Node{
    BigHero data;
    Node* Next;

    };

  // Funtion Prototypes
  int countHeros(string,int&);
  void createList(BigHero,int,Node*&,Node*&,Node*&);
  void printList(Node*,Node*,Node*);
  void deallocateList(Node*&,Node*&,Node*&);

  int main()
 {
      // Program Variables
      Node* head;
      Node* currentPtr;
      Node* newNodePtr;

     string Filename = "ola5party.dat"; // File string varible
     int charNumber = 0; // variable to hold number of Heroes
     int i = 0; // Loop control varible


    countHeros(Filename,charNumber); // Function call used to count number of   Heros

     ifstream inFile;
     inFile.open(Filename.c_str());
     if(!inFile){
     cout << "Error in opening file" << endl;
     return 0;
     }

      BigHero Hero;
     while(inFile)
       {
          inFile >> Hero;
          createList(Hero,charNumber,head,currentPtr,newNodePtr);
       }

    printList(head,currentPtr,newNodePtr);

    deallocateList(head,currentPtr,newNodePtr);




    inFile.close();

    return 0;



}

  int countHeros(string Filename,int& charNumber)
  {
     ifstream inFile;
     inFile.open(Filename.c_str());
     string aLineStr;
     while (getline(inFile, aLineStr))
         {
           if (!aLineStr.empty())
           charNumber++;
         }

          inFile.close();
          return charNumber;
     }

    void createList(BigHero Hero, int charNumber,Node*& head, Node*& currentPtr, Node*& newNodePtr)
    {


         head = new Node;
         head->data =Hero;
         currentPtr = head;

         newNodePtr = new Node;
         cout << "Allocated # " << newNodePtr << endl;
         newNodePtr->data = Hero;
         currentPtr->Next = newNodePtr;
         currentPtr = newNodePtr;




        }

         void printList(Node* head, Node* currentPtr, Node* newNodePtr)
         {
                if(head != NULL)
                {
                  currentPtr = head;

                    while(currentPtr->Next != NULL)
                    {
                       cout << currentPtr->data << endl;
                        currentPtr = currentPtr->Next;
         }

      }

    }

       void deallocateList(Node*& head ,Node*& currentPtr,Node*& newNodePtr)
       {
            if( head != NULL)
             {
                currentPtr = head;
                while( head -> Next != NULL)
                {

                    head = head->Next;
                    cout << "Deleting # " << head << endl;
                    delete currentPtr;
                    currentPtr = head;


             }
             delete head;

             head = NULL;
             currentPtr = NULL;


            }
       }

像这样的程序运行没有错误，但问题是它将输入所需的所有信息，但由于我只有一个变量英雄类，所以它不断替换信息。

我试图制作一个类数组（示例英雄[i]），但似乎无法正确，甚至不确定这是否是解决方案。一切都很好，但我不能得到所需数量的类对象，我总是最终得到一个类

这是我想要的输出，但我只得到一个类对象

     Allocated#0x8722178
     Allocated#0x87221d0
     Allocated#0x8722210
     Allocated#0x8722230
     Allocated#0x8722288
     Allocated#0x87222c8
     Hero:MacWarriorLevel134,(34,16,48)Exp:13425
     Hero:LinuxMageLevel149,(24,54,21)Exp:14926
     Hero:PCBardLevel122,(18,32,17)Exp:12221
     Hero:PythonThiefLevel90,(24,18,61)Exp:9001
     Hero:CplusPaladinLevel159,(31,38,29)Exp:15925
     Deleting#0x8722178
     Deleting#0x87221d0
     Deleting#0x8722210
     Deleting#0x8722230
     Deleting#0x8722288
     Deleting#0x87222c8

Answer 1

您似乎误解了所列链接背后的基本理念。添加元素时，不应该一次又一次地覆盖head。只有在列表为空时才会更改head。

尝试这样的事情：

struct Node
{
    BigHero data;
    Node* next;
};


void addNewNode(Node*& head, ....)
{
    if (head == nullptr)
    {
        // List empty so add new node as head
        head = new Node;
        head->next = nullptr;
        return;
    }

    // Find last element in list (performance can be improved with a tail*)
    Node* temp = head;
    while (temp->next != nullptr) temp = temp->next;

    // Add new element to end of list
    temp->next = new Node;
    temp->next->next = nullptr

    return;        
}

int main()
{
    Node* head = nullptr;

    addNewNode(head, ....);

    return 0;
}

对于性能，通常也有一个尾指针。

此外，您不应在head中定义main()，而是为其创建一个类/结构，并将相关函数放在类中。像：

struct Node
{
    BigHero data;
    Node* next;
};

class ListOfNode
{
    public:
    ListOfNode() : head(nullptr), size(0) {}

    ~ListOfNode()
    {
        // Delete all nodes
    }


    void addNewNode(....)
    {
        // ....

        ++size;
    }

    size_t size() { return size; }

    private:
    Node* head;  // Optional: Add a tail* for better performance
    size_t size;
};

int main()
{
    ListOfNode list;

    list.addNewNode(....);

    cout << list.size() << endl;

    return 0;
}

链接列表类

1 个答案: