Перегрузка оператора + - C++ - Ответ 4981373

#include <iostream>
 
//enum ddd {kIsSmaller, kIsSame, kIsLarger};
 
bool Compare(const int & itsval,const int & val)
{
    if (itsval > val)
    return false;
    if (itsval < val)
    return true;
    else
    return false;
}
 
class Node;
class OrdNode;
class HeadNode;
class TailNode;
 
class Node
{
    public:
        Node() {}
        virtual ~Node() {};
        virtual Node* Insert(const int* theValue) = 0;
        virtual void Show() = 0;
    private:
};
 
class OrdNode : public Node
{
    public:
        OrdNode(const int* theValue, Node* next);
        virtual~OrdNode() {delete myValue; delete myNext;}
        virtual Node* Insert(const int*  theValue);
        virtual void Show() {std::cout << *myValue << std::endl; myNext -> Show();}
   private:
        const int* myValue;
        Node* myNext; 
};
 
OrdNode::OrdNode(const int* theValue, Node* next):
    myValue(theValue),
    myNext(next)
{
}
 
Node* OrdNode::Insert(const int* theValue)
{
    bool result = Compare(*myValue, *theValue);
    if (!result)
    {
        OrdNode* newnode = new OrdNode(theValue,this);
        return newnode;
    }
    else
    {
        myNext = myNext->Insert(theValue);
        return this;
    }
    return this; 
}
 
class TailNode : public Node
{
    public:
        TailNode() {}
        ~TailNode(){}
        virtual Node* Insert(const int* theValue);
        virtual void Show() {};
    private:
};
 
Node* TailNode::Insert(const int* theValue)
{
    OrdNode* newnode = new OrdNode(theValue, this);
    return newnode;
}
 
class HeadNode : public Node
{
    public:
        HeadNode();
        ~HeadNode();
        virtual Node* Insert(const int* theValue);
        virtual void Show() {myNext -> Show();}
    private:
        Node* myNext;
};
 
HeadNode::HeadNode()
{
    myNext = new TailNode;
}
 
HeadNode::~HeadNode()
{
    delete myNext;
}
 
Node* HeadNode::Insert(const int* theValue)
{
    myNext = myNext->Insert(theValue);
    return this;
}
 
class LList
{
    public:
        LList();
        ~LList();
        LList(const LList &  rhs);
        void Insert(const int* theValue);
        void ShowAll();
        LList operator+(const int* rhs);
    private:
        HeadNode* myHead;
};
 
LList::LList(const LList & rhs)
{
    myHead = rhs.myHead;
}
 
LList LList::operator+(const int* rhs)
{
     LList temp = *this;
     temp.Insert(rhs);
     return temp;
}
 
LList::LList()
{
    myHead = new HeadNode;
}
 
LList::~LList()
{
    delete myHead;
}
 
void LList::Insert(const int* theValue)
{
    myHead -> Insert(theValue);
}
 
void LList::ShowAll()
{
    myHead->Show();    
}
 
int main()
{
    system("chcp 1251");
    system("cls");
    LList ll;
    int * pData;
    int val;
    /*for (;;)
    {
        std::cout << "What value? (0 to stop): ";
        std::cin >> val;
        if (!val)
        {
            break;
        }
        pData = new int;
        *pData = val;
        ll.Insert(pData);
    }*/
    pData = new int;
    *pData = 0;
    ll = ll + pData;
    ll.ShowAll();
    system("pause");
    return 0;
}