Can anyone help me fix this error?

[AL88]

Qualified - id in declaration before '(' token

void PartsCatalog::Insert(Part * newPart)
^

  #include <iostream>

typedef unsigned long ULONG;
typedef unsigned short USHORT;
// 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:
    friend class PartsList;
    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
}

// ******** Parts 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->itsPart;
        else
            return NULL;
}

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->itsNext;
                 
                 return pNode->itsPart;
}

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

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

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->itsPart->GetPartNumber() > New)
{
    pNode->itsNext = pHead;
    pHead = pNode;
    return;
}

for (;;)
{
    // if there is no next, append this new one
    if(!pCurrent->itsNext)
    {
        pCurrent->itsNext = pNode;
        return;
    }
    
// if this goes after this one and before the next
// then insert it here, otherwise get the next
pNext = pCurrent->itsNext;
Next = pNext->itsPart->GetPartNumber();
if(Next > New)
{
    pCurrent->itsNext = pNode;
    pNode->itsNext = pNext;
    return;
}
pCurrent = pNext;
}

class PartsCatalog : private PartsList
{
public:
    void Insert(Part *);
    ULONG Exists(ULONG PartNumber);
    Part * Get(int PartNumber);
    operator+(const PartsCatalog &);
    void ShowAll() { Iterate(&Part::Display);}
    private:
};

void PartsCatalog::Insert(Part * newPart)
{
    ULONG partNumber = newPart->GetPartNumber();
    ULONG offset;
    
    if (!Find(offset, partNumber))
        PartsList::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+ << "th ";
            }
            std::cout<<"entry. Rejected!\n";
        }
}

ULONG PartsCatalog::Exists(ULONG PartNumber)
{
    ULONG offset;
    Find(offset,PartNumber);
    return offset;
}

Part * PartsCatalog::Get(int PartNumber)
{
    ULONG offset;
    return (Find(offset, PartNumber));
}

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::cout >> value;
                pPart = new CarPart(value,PartNumber);
            }
            else
            {
                std::cout<<"Engine Number?: ";
                std::cin>> value;
                pPart = new AirPlane(value,PartNumber);
            }
            pc.Insert(pPart);
    }
    pc.ShowAll()
}

[keskiverto]

That is not the first error:

242:35: error: ISO C++ forbids declaration of 'operator+' with no type [-fpermissive]
247:26: error: qualified-id in declaration before '(' token 

Fix the first error first.

[Repeater]

Your function void PartsList::Insert(Part* pPart) never ends.

You can't see it because around line 206 you gave up on sensible indentation.

[MikeyBoy]

This is a duplicate of http://www.cplusplus.com/forum/beginner/243219/ . You were given plenty of helpful advice in that thread, that would have helped you find and fix the problem, if you'd paid any attention to it.

(That advice has been repeated in this new thread. I wonder if you'll pay any attention this time?)

DON'T spam the forum with multiple threads for the same problem. It wastes everyone's time.