Can anyone help explain these errors

[AL88]

^
/home/alistair/Codelite/AnIntroductionToProgramming/14_5/14_5/14_5/main.cpp: In member function 'void PartsList::Insert(Part*)::PartsCatalog::ShowAll()':
/home/alistair/Codelite/AnIntroductionToProgramming/14_5/14_5/14_5/main.cpp:250:50: error: invalid use of non-static member function 'virtual void Part::Display() const'
void ShowAll() { thePartsList.Iterate(Part::Display); }
^
/home/alistair/Codelite/AnIntroductionToProgramming/14_5/14_5/14_5/main.cpp: In member function 'void PartsList::Insert(Part*)':
/home/alistair/Codelite/AnIntroductionToProgramming/14_5/14_5/14_5/main.cpp:255:27: error: qualified-id in declaration before '(' token
void PartsCatalog::Insert(Part * newPart)
^
/home/alistair/Codelite/AnIntroductionToProgramming/14_5/14_5/14_5/main.cpp:326:1: error: expected '}' at end of input
}
^
14_5.mk:95: recipe for target 'Debug/main.cpp.o' failed
make: *** [Debug/main.cpp.o] Error 1
====3 errors, 8 warnings====

#include <iostream>

typedef unsigned long ULONG;
typedef unsigned short USHORT;

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

// Abstract base of parts

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

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

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

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

// ********* Airplane Part *********
class AirPlanePart : public Part
{
public:
    AirPlanePart():itsEngineNumber(1){};
    AirPlanePart(USHORT EngineNumber, ULONG PartNumber);
    virtual void Display() const { Part::Display(); std::cout <<"Engine No.."<< itsEngineNumber<< std::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!
    void Iterate(void(Part::*f)()const) const;
    Part * Find(ULONG & position, ULONG Partnumber) const;
    Part* GetFirst() const;
    void Insert(Part*);
    Part* operator[] (ULONG) const;
    ULONG GetCount() const { return itsCount;}
    static PartsList& GetGlobalPartsList() { return GlobalPartsList;}
    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;
 }
 
 class PartsCatalog
 {
        public:
     void Insert(Part *);
     ULONG Exists(ULONG PartNumber);
     Part * Get(int PartNumber);
     operator=(const PartsCatalog &);
     void ShowAll() { thePartsList.Iterate(Part::Display); }
        private:
     PartsList thePartsList;
 };
 
 void PartsCatalog::Insert(Part * newPart)
 {
     ULONG partNumber = newPart->GetPartNumber();
     ULONG offset;
     
     if (!thePartsList.Find(offset, partNumber))
         thePartList.Insert(newPart);
         else
         {
             std::cout << partNumber << " was the ";
             switch (offset)
             {
                 case 0: std::cout << "first " ; break;
                 case 1: std::cout << "second " ;break;
                 case 2: std::cout << "third " ; break;
                 default: std::cout << offset+1 << "th ";
             }
             
             std::cout <<"entry. Rejected!\n";
         }
 }
 
 ULONG PartsCatalog::Exists(ULONG PartNumber)
 {
     ULONG offset;
     thePartList.Find(offset,PartNumber);
     return offset;
 }
 
 Part * PartsCatalog::Get(int PartNumber)
 {
     ULONG offset;
     Part * thePart = thePartsList.Find(offset, PartNumber);
     return thePart;
 }
 

int main()
{
PartsCatalog pc;
Part * pPart = 0;
ULONG PartNumber;
USHORT value;
ULONG choice;

while(1)
{
    std::cout<< "(0)Quit (1)Car (2)Plane: ";
    std::cin>> choice;
    
    if(!choice)
        break;
        
        std::cout <<"New Part Number?: ";
        std::cin >> PartNumber;
        
        if(choice == 1)
        {
            std::cout<<"Model Year?:" ;
            std::cin>> value;
            pPart = newCarPart(value, PartNumber);
        }
        else
        {
            std::cout <<"Engine Number?: ";
            std::cin>>value;
            pPart = newAirPlane(value, PartNumber);
        }
    pc.Insert(pPart);
    }
        pc.ShowAll();
}

[Peter87]

To get a pointer to a member function you need to use the & operator.

thePartsList.Iterate(&Part::Display);

[AL88]

what about void PartsCatalog::Insert(Part * newPart)
?
thanks

[MikeyBoy]

What about it? Can you clarify what it is you're asking?

[AL88]

error : qualified id in declaration before ( token

void PartsCatalog::Insert(Part * newPart)
^

[MikeyBoy]

It's hard to see, because your indentation is a mess, but it looks to me like you never close your PartsList::Insert() function definition with a closing brace. So you're actually trying to define PartsCatalog::Insert() inside PartsList::Insert(), which is illegal.

This is the point where I point out that you would find it so much easier to spot these kinds of problems if you adopted a consistent and sensible indentation style.

[AL88]

sorry about the indentation, can you give me the line number where the cloding brace is missing ? thanks.

[MikeyBoy]

sorry about the indentation

There's no need to apologize to us. It's you who's affected if your code is hard to read, not us.

can you give me the line number where the cloding brace is missing ?

As I've said, it's the end of the PartsList::Insert() function. Surely you know where your own function is supposed to end?

[mbozzi]

Consistent indentation will help. Maybe begin using a tool like ClangFormat to format your code.
https://clang.llvm.org/docs/ClangFormat.html
Ideally you can set up your editor to do this with a keystroke.