如何在链表中显示特定节点？ 我对C++是相当新的。< /P>

我有一份作业中的代码，我不太了解所有代码，但我必须让程序在最后给用户一个选项，让用户回忆输入的任何零件号和年款/发动机号。

我不知道如何着手做这项任务。。。也许每个节点都有某种id，这样我就能回忆起它了

还是我唯一的选择是使用数组或向量数据结构重写程序

     #include <iostream>

     using namespace std;

     typedef unsigned long ULONG;
     typedef unsigned short USHORT;


     // **************** Part ************

     // Abstract base class of parts
     class Part
     {
     friend void showPart();

     public:
        Part():itsPartNumber(1) {}
        Part(ULONG PartNumber):itsPartNumber(PartNumber){}
        virtual ~Part(){};
        ULONG GetPartNumber() const { return itsPartNumber; }
        virtual void Display() const =0;  // must be overridden
     private:
        ULONG itsPartNumber;
     };

     // implementation of pure virtual function so that
     // derived classes can chain up
     void Part::Display() const
     {
         cout << "\nPart Number: " << itsPartNumber << endl;
     }
     // **************** Car Part ************

     class CarPart : public Part
     {
     friend void showPart();

     public:
        CarPart():itsModelYear(94){}
        CarPart(USHORT year, ULONG partNumber);
        virtual void Display() const
       {
          Part::Display(); cout << "Model Year: ";
          cout << itsModelYear << endl;
       }
     private:
        USHORT itsModelYear;
     };

     CarPart::CarPart(USHORT year, ULONG partNumber):
        itsModelYear(year),
        Part(partNumber)
     {}


     // **************** AirPlane Part ************

     class AirPlanePart : public Part
     {
     friend void showPart();

     public:
        AirPlanePart():itsEngineNumber(1){};
        AirPlanePart(USHORT EngineNumber, ULONG PartNumber);
        virtual void Display() const
       {
          Part::Display(); cout << "Engine No.: ";
          cout << itsEngineNumber << endl;
       }
     private:
        USHORT itsEngineNumber;
     };

     AirPlanePart::AirPlanePart(USHORT EngineNumber, ULONG PartNumber):
        itsEngineNumber(EngineNumber),
        Part(PartNumber)
     {}

     // **************** Part Node ************
     class PartNode
     {
     public:
         PartNode (Part*);
         ~PartNode();
         void SetNext(PartNode * node) { itsNext = node; }
         PartNode * GetNext() const;
         Part * GetPart() const;
      private:
         Part *itsPart;
         PartNode * itsNext;
      };

      // PartNode Implementations...

      PartNode::PartNode(Part* pPart):
      itsPart(pPart),
      itsNext(0)
      {}

      PartNode::~PartNode()
      {
         delete itsPart;
         itsPart = 0;
         delete itsNext;
         itsNext = 0;
      }

      // Returns NULL if no next PartNode
      PartNode * PartNode::GetNext() const
      {
            return itsNext;
      }

      Part * PartNode::GetPart() const
      {
         if (itsPart)
            return itsPart;
         else
            return NULL; //error
      }

      // **************** Part List ************
      class PartsList
      {
      public:
         PartsList();
         ~PartsList();
         // needs copy constructor and operator equals!
         Part*      Find(ULONG & position, ULONG PartNumber)  const;
         ULONG      GetCount() const { return itsCount; }
         Part*      GetFirst() const;
         static     PartsList& GetGlobalPartsList()
       {
          return  GlobalPartsList;
       }
         void       Insert(Part *);
         void       Iterate(void (Part::*f)()const) const;
         Part*      operator[](ULONG) const;
      private:
         PartNode * pHead;
         ULONG itsCount;
         static PartsList GlobalPartsList;
      };

      PartsList PartsList::GlobalPartsList;

      // Implementations for Lists...

      PartsList::PartsList():
         pHead(0),
         itsCount(0)
         {}

      PartsList::~PartsList()
      {
         delete pHead;
      }

      Part*   PartsList::GetFirst() const
      {
         if (pHead)
            return pHead->GetPart();
         else
            return NULL;  // error catch here
      }

      Part *  PartsList::operator[](ULONG offSet) const
      {
         PartNode* pNode = pHead;

         if (!pHead)
            return NULL; // error catch here

         if (offSet > itsCount)
            return NULL; // error

         for (ULONG i=0;i<offSet; i++)
            pNode = pNode->GetNext();

        return   pNode->GetPart();
      }

      Part*   PartsList::Find(ULONG & position, ULONG PartNumber)  const
      {
         PartNode * pNode = 0;
         for (pNode = pHead, position = 0;
               pNode!=NULL;
               pNode = pNode->GetNext(), position++)
         {
            if (pNode->GetPart()->GetPartNumber() == PartNumber)
               break;
         }
         if (pNode == NULL)
            return NULL;
         else
            return pNode->GetPart();
      }

      void PartsList::Iterate(void (Part::*func)()const) const
      {
         if (!pHead)
            return;
         PartNode* pNode = pHead;
         do
            (pNode->GetPart()->*func)();
         while (pNode = pNode->GetNext());
      }

      void PartsList::Insert(Part* pPart)
      {
         PartNode * pNode = new PartNode(pPart);
         PartNode * pCurrent = pHead;
         PartNode * pNext = 0;

         ULONG New =  pPart->GetPartNumber();
         ULONG Next = 0;
         itsCount++;

         if (!pHead)
         {
            pHead = pNode;
            return;
         }

         // if this one is smaller than head
         // this one is the new head
         if (pHead->GetPart()->GetPartNumber() > New)
         {
            pNode->SetNext(pHead);
            pHead = pNode;
            return;
         }

         for (;;)
         {
            // if there is no next, append this new one
            if (!pCurrent->GetNext())
            {
               pCurrent->SetNext(pNode);
               return;
            }

            // if this goes after this one and before the next
            // then insert it here, otherwise get the next
            pNext = pCurrent->GetNext();
            Next = pNext->GetPart()->GetPartNumber();
            if (Next > New)
            {
               pCurrent->SetNext(pNode);
               pNode->SetNext(pNext);
               return;
            }
            pCurrent = pNext;
         }
      }

      int main()
      {
         PartsList pl = PartsList::GetGlobalPartsList();
         Part * pPart = 0;
         ULONG PartNumber;
         USHORT value;
         ULONG choice;

         while (1)
         {
            cout << "(0)Quit (1)Car (2)Plane: ";
            cin >> choice;

            if (!choice)
               break;

            cout << "New PartNumber?: ";
            cin >>  PartNumber;

            if (choice == 1)
            {
               cout << "Model Year?: ";
               cin >> value;
               pPart = new CarPart(value,PartNumber);
            }
            else
            {
               cout << "Engine Number?: ";
               cin >> value;
               pPart = new AirPlanePart(value,PartNumber);
            }

            pl.Insert(pPart);
         }
         void (Part::*pFunc)()const = &Part::Display;
         pl.Iterate(pFunc);

         cout << "\n\n\nThere are " << pl.GetCount() << " items in the list" << endl;


        return 0;
     }

#包括
使用名称空间std；
typedef无符号长ULONG；
typedef无符号短USHORT；
//****************部分************
//零件抽象基类
班级部分
{
朋友无效显示部分（）；
公众：
Part（）：它的partnumber（1）{}
零件（ULONG零件号）：其零件号（零件号）{}
虚~Part（）{}；
ULONG GetPartNumber（）常量{返回其PartNumber；}
virtual void Display（）const=0；//必须重写
私人：
ULONG及其零件号；
};
//实现纯虚函数，使
//派生类可以链接起来
无效部分：：Display（）常量
{
cout*func）（）；
而（pNode=pNode->GetNext（））；
}
无效零件列表：：插入（零件*pPart）
{
PartNode*pNode=新的PartNode（pPart）；
PartNode*pCurrent=pHead；
PartNode*pNext=0；
ULONG New=pPart->GetPartNumber（）；
ULONG Next=0；
itscont++；
如果（！pHead）
{
pHead=pNode；
返回；
}
//如果这个比头小
//这是新的头
如果（pHead->GetPart（）->GetPartNumber（）>新建）
{
pNode->SetNext（pHead）；
pHead=pNode；
返回；
}
对于（；；）
{
//如果没有下一个，请附加此新的
如果（！pcCurrent->GetNext（））
{
pCurrent->SetNext（pNode）；
返回；
}
//如果这件事发生在这件事之后下件事之前
//然后将其插入此处，否则将获取下一个
pNext=pCurrent->GetNext（）；
Next=pNext->GetPart（）->GetPartNumber（）；
如果（下一步>新建）
{
pCurrent->SetNext（pNode）；
pNode->SetNext（pNext）；
返回；
}
pCurrent=pNext；
}
}
int main（）
{
PartsList pl=PartsList:：GetGlobalPartsList（）；
零件*pPart=0；
乌龙零件号；
USHORT值；
乌龙选择；
而(1)
{
选择；
如果（！选择）
打破
cout>零件号；
如果（选项==1）
{
cout>值；
pPart=新零件（值、零件号）；
}
其他的
{
cout>值；
pPart=新的AirPlanePart（值、零件号）；
}
pl.插入（pPart）；
}
void（Part:：*pFunc）（）const=&Part:：Display；
pl.Iterate（pFunc）；
cout类
PartsList
已经有一个
Find（）
方法，可用于根据零件号检索任何零件。然后可以调用该零件的
Display（）
方法。
函数Find确实获取零件号，但返回指向零件的指针，该指针与零件地址不同（这将是一个引用，用&）表示。此外，Find引用一个名为“position”的变量，因此在调用Find函数后，传递给“position”的变量将包含零件在链表中的位置的值

你不能使用的原因是，如果你对你的问题更清楚一些，我的理解是，Find（）获取零件号并返回该零件的地址，对吗？我如何将其分配给指针并取消引用？非常感谢Merlin您的回答对我帮助很大，而且很有效。我将尝试更好地理解多态性。谢谢：）
    int findnumber;
         ULONG position;
         cout << "Enter Partnumber" << endl;
         cin >> findnumber;
         Part* show = pl.Find(position, findnumber);
         cout << *show;

Part* part = pl.Find(position, findnumber);
part->Display();