двухсвязный список и множества

#include<iostream>
#include<windows.h>
 
using namespace std;
 
class List;
 
//______________________________________________________________________________________________________
 
class ListItem
{
    private:
        int data;
        ListItem *pNext, *pPrev;
    public:
        ListItem()
        {
            pNext=NULL;
            pPrev=NULL;
            data=0;
        }
 
        ListItem(int data)
        {
            pNext=NULL;
            pPrev=NULL;
            this->data=data;
        }
 
        ~ListItem(void)
        {
            pNext=NULL;
            pPrev=NULL;
        }
 
        friend List;    
};
 
//______________________________________________________________________________________________________
 
class List
{
    private:
        ListItem*pHead;
        int count;
 
    public:
        List()
        {
            pHead=0;
            count=0;
        }
 
        List(List &obj)
        {
            count=0;
            pHead=0;
            ListItem *temp=obj.pHead;
            while(temp)
            {
                this->AddToTail(temp->data);
                temp=temp->pNext;
            }
        
        }
 
        ~List()
        {
            if(pHead!=0)
            {
                ListItem *show=pHead;
                while(show)
                {
                    show=show->pNext;
                    if(show) delete show->pPrev;
                }
            }
        }
        
        const int GetCount()const {return count;}
 
        void AddToHead(int dt)
        {
            ListItem *tmp = new ListItem();
            tmp->data=dt;
            if(pHead==0)pHead=tmp;
            else
            {
                pHead->pPrev=tmp;//Бывшее начало связываем с новым первым
                tmp->pNext=pHead;//Первый со вторым
                pHead = tmp;//Голову с новым первым
            }
            count++;//Увеличиваем счетчик элементов
        }
 
        void AddToTail(int dt)
        {
            ListItem *tmp = new ListItem();
            tmp->data=dt;
            ListItem*pt=pHead;
            if(pHead==0)pHead=tmp;
            else
            {
                while(pt!=0)
                {
                    if(pt->pNext==0)
                    {
                        pt->pNext=tmp;
                        break;
                    }
                    pt=pt->pNext;
                }
            }
            count++;//Увеличиваем счетчик элементов
        }
    
 
        void showAll()
        {
            ListItem *t=pHead;
            while(t)
            {
                cout<<t->data<<" ";
                t=t->pNext;
            }
            cout<<endl;
        }
 
        void Insert(int data, int pos)
        {
            int i=0;
            if(!pos)
            {
                AddToHead(data);
                return;
            }
 
            if(pos==count-1) 
            {
                AddToTail(data);
                return;
            }
 
            ListItem *tmp = new ListItem(data);
 
            if((pos<0)||(pos>=count)) 
            {
                cout<<"Ошибка ввода вставки на ["<<pos<<"] позицию"<<endl;
                delete tmp;
                return;
            }
 
            ListItem *show=pHead;
 
            while(show)
            {
                if(i++==pos)
                {
                    tmp->pNext=show;
                    tmp->pPrev=show->pPrev;
                    show->pPrev->pNext=tmp;
                    show->pPrev=tmp;
 
                    count++;
 
                    break;
                }
            show=show->pNext;
            }
        }
 
    void Delete(int pos)
    {
        int i=0;
        ListItem *t=this->pHead;
        if(pos<0||pos>=count) {cout<<"ОШИБКА! Значение не соответствует количеству элементов!"; return;}
 
        while(t)
        {
            if(i==pos)
            {
                if(count==1)
                {
                    delete t;
                    pHead=0;
                    count--;
                    return;
                }
 
                else
                {
                    if(t==pHead)
                    {
                        t->pNext->pPrev = 0;
                        pHead = t->pNext;                   
                    }
    
                    else if(t->pNext==0)
                    {
                        t->pPrev->pNext = 0;
                    }
 
                    else
                    {
                        t->pNext->pPrev = t->pPrev;
                        t->pPrev->pNext = t->pNext;
                    }
 
                delete t;
                count--;
                return;
            }
            }
        t=t->pNext;
        i++;
    }
    }
 
    int &operator[](int pos)
    {
        int i=0;
        if((pos<0)||(pos>=count)) return pHead->data;
        ListItem *show=pHead;
        while(show)
        {
            if(i++==pos) return show->data;
            show=show->pNext;
        }
        return pHead->data;
    }
 
    List Intersection(List& a, List &b)//Доделать пересечение 
    {
 
        ListItem *t=pHead=a.pHead;
 
        while(t)
        {
            ListItem *t2=pHead=b.pHead;
            //if (t==t2);
        }
    }
List Exception(List& a,List &b)
    {
        List copy_a(a);
        List copy_b(b);
        ListItem *pt=copy_a.pHead;
        int count_of_position=0;
        while(pt!=0)
        {
            bool flag_pt=true;
            ListItem *pt2=copy_b.pHead;
            while(pt2!=0)
            {
                if(pt->data==pt2->data)
                {
                    flag_pt=false;
                    //pt=pt->pNext;
                    //delete pt;
                    //pHead=0;
                    copy_a.Delete(count_of_position);
                    pt=pt->pNext;
                    break;
                }
                pt2=pt2->pNext; 
            }
            if (flag_pt)
            {
                pt=pt->pNext;
                count_of_position++;
            }
            delete pt2;
        }
        delete pt;
        
        return copy_a;
    }
};
 
//------------------------------------------Main------------------------------------------------------------------
 
int _tmain(int argc, _TCHAR* argv[])
{
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);
 
    List a;
        for (int i=0;i<10;i++)
    {
        a.AddToHead(rand()%20);
    }
    a.showAll();
 
    List b;
    for (int i=0;i<10;i++)
    {
        b.AddToHead(rand()%20);
    }
    b.showAll();
 
    List c;
    c.Exception(a,b);
    c.showAll();
 
    return 0;
}