Объяснить почему программа уходит в бесконечный цикл (связные списки)

#include <iostream>
#include <random>
#include <time.h>
#include <string.h>
#include "связанный список.h"
using namespace std;
typedef unsigned short USHORT;
int main()
{
    setlocale (LC_ALL, "rus");
    //srand (time(NULL));
    USHORT weght, price;
    char name [40];
    LinkedList List;
    Cargo * pCargo;
    for ( ; ; ){
        cout << " Если Вес равен нулю, Вод прекратиться!Введите вес. : ";
        cin >> weght;
        cout << endl;
        if (!weght)
            break;
        cout << "Введите цену: ";
        cin >> price;
        cout << endl;
        cout << "Введите название продукта: ";
        pCargo = new Cargo(weght, price);
        cin.get(name, 39);
        pCargo->SetName(name);
 
        List.Insert(pCargo);
 
    }
    system("cls");
    List.ShowAll();
 
    system("pause");
    return 0;
}
 
 
вод заголовочный файл:
using namespace std;
typedef unsigned short USHORT;
enum {SMALLER, LARGER, SAME};
 
class Cargo
{
public:
    Cargo(USHORT weight, USHORT price);
    ~Cargo(){}
    USHORT Compare(const Cargo & lTheCargo);
    void SetName(char n[40]){ strcpy(name,n); }
    
    void Show()
    {    
        cout << "название продукта: " << name;
        cout << "\tВес груза: \t" << Weight << "   "; 
        cout << "\tЦена груза: \t" << Price << endl;
        
    }
private:
    USHORT Weight;
    USHORT Price;
    char name[40];
};
Cargo::Cargo (USHORT weight, USHORT price) : Weight(weight) , Price (price)
{
 
}
USHORT Cargo::Compare (const Cargo & lTheCargo)
{
    if (Weight < lTheCargo.Weight)
        return SMALLER;
 
    else if (Weight > lTheCargo.Weight)
        return LARGER;
 
    else
        return SAME;
}
 
class Node;
class HeadNode;
class InternalNode;
class TailNode;
 
class Node
 {
public :
    Node ( ) { }
    virtual ~Node() { }
    virtual Node * pInsert(Cargo * pTheCargo) = 0;
    virtual void Show() = 0;
private:
};
 
class InternalNode  :  public Node
 {
public :
    InternalNode(Cargo * pTheCargo, Node * pnext ) ;
    ~InternalNode(){ delete pMyNext; pMyCargo; }
    virtual Node * pInsert(Cargo * pTheCargo) ;
    virtual void Show(){ pMyCargo->Show( ) ; pMyNext->Show () ; }
 
private:
    Cargo * pMyCargo;
    Node * pMyNext;
};
InternalNode::InternalNode(Cargo * pTheCargo, Node * pnext) : pMyCargo(pTheCargo) , pMyNext(pnext)
{
 
}
Node * InternalNode::pInsert(Cargo * pTheCargo)
{
    USHORT result = pMyCargo->Compare(*pTheCargo ) ;
    switch (result)
    {
    case SAME:
    case SMALLER:
    {
                   InternalNode * CargoNode = new InternalNode(pTheCargo, this ) ;
                   return CargoNode;
    }
    case LARGER:
        pMyNext = pMyNext->pInsert(pTheCargo ) ;
        return this;
    }
    return this;
}
 
class TailNode : public Node
{
public:
    TailNode(){}
    ~TailNode(){}
    virtual Node * pInsert(Cargo * pTheCargo) ;
    void Show(){}
private:
};
 
Node * TailNode::pInsert(Cargo * pTheCargo)
{
    InternalNode * CargoNode = new InternalNode(pTheCargo, this ) ;
    return CargoNode;
}
 
class HeadNode : public Node
{
public:
    HeadNode();
    ~HeadNode(){ delete pMyNext; }
    Node * pInsert(Cargo * pTheCargo ) ;
    void Show(){ pMyNext->Show( ) ; }
private:
    Node * pMyNext;
};
 
 HeadNode::HeadNode()
{
    pMyNext = new TailNode;
}
 Node * HeadNode::pInsert(Cargo * pTheCargo)
 {
     pMyNext = pMyNext->pInsert(pTheCargo ) ;
     return this;
 }
 
 class LinkedList
 {
 public:
     LinkedList();
     ~LinkedList(){ delete pMyHead; }
     void Insert(Cargo * pCargo);
     void ShowAll(){ pMyHead->Show( ) ; }
 private:
     HeadNode * pMyHead;
 };
 LinkedList::LinkedList()
 {
     pMyHead = new HeadNode;
 }
 
 void LinkedList::Insert(Cargo * pCargo)
 {
     pMyHead->pInsert(pCargo) ;
 }

(cin >> price).get();