Записи в линейном списке содержат ключевое поле типа int. Сформиро-вать двунаправленный список. Добавить в него элемент с заданным номером, удалить К

#include <iostream>
 
class L2_elem
{
public: 
    char el;
    L2_elem* next;
    L2_elem* prev;
    L2_elem();                                      //çàíóëèòü óêàçàòåëè
    L2_elem (char c, L2_elem* n,L2_elem* p);        //ïðèñâàèâàíèå çíà÷åíèé
    char get_el();
    L2_elem* get_n();
    L2_elem* get_p();
};
class L2 
{
    L2_elem* head;                              // ãîëîâà
    L2_elem* tail;                              // õâîñò
    L2_elem* GetElemById(int i);
    
public:
    L2();                                       // èíèöèàëèçàöèÿ
    ~L2();                                      // äåñòðóêòîð
    L2(const L2 &List);                         // êîïèðîâàíèå
    L2& operator = (const L2& List);            // îïåðàòîð ïåðåãðóçêè
    bool isEmpty ()const;                       // ïðîâåðêà íà ïóñòîòó
    char popHead ();                            // ïîëó÷èòü ýëåìåíò èç íà÷àëà ñïèñêà
    char popTail ();                            // ïîëó÷èòü ýëåìåíò èç êîíöà ñïèñêà
    void pushHead (char c);                     // äîáàâèòü ýëåìåíò â íà÷àëî ñïèñêà
    void pushTail (char c);                     // äîáàâèòü ýëåìåíò â êîíåö ñïèñêà       
    void AddAfter(char c, int i);               // äîáàâèòü ýëåìåíò ïîñëå çàäàííîãî
    char DelAfter( int i);                      // óäàëèòü ýëåìåíò ïîñëå çàäàííîãî
    
    void printTail()const;                      // ïå÷àòü ñ õâîñòà
    int size ()const;                           // ðàçìåð ñïèñêà
    void makeEmpty();                           // ñäåëàòü ïóñòûì
    static void L2_menu();
    friend std::istream& operator>>(std::istream& i, L2& L);
    friend std::ostream& operator<<(std::ostream& o, const L2& L);
};

#include <iostream>
#include "L2.h"
#include "error.h"
using namespace std;
L2_elem :: L2_elem()
    : prev(0), next(0)
{
    
}
char L2_elem :: get_el()
{
    return el;
}
 
L2_elem*  L2_elem :: get_p()
{
    return prev;
}
 
L2_elem :: L2_elem (char c, L2_elem* n,L2_elem* p)      //ïðèñâàèâàíèå çíà÷åíèé
{
    el = c;
    next = n;
    prev = p;
}
 
 
//ðåàëèçàöèÿ L2
 
L2 :: L2()
{
    head = 0;                                           // ïî óìîë÷àíèþ âûçûâàåòñÿ êîíñòðóêòîð áåç ïàðàìåòðîâ L2_elem
    tail = 0;
}
 
bool L2 :: isEmpty () const                                 // ïðîâåðêà íà ïóñòîòó
{
    return head == 0;
} 
 
void L2 :: makeEmpty()                                  // î÷èñòèòü òåêóùèé ñïèñîê
{   
    
    L2_elem* p = 0;
    while (head)
    {
        p = head;
        head = head->next;          
        delete p;
    }
    head = 0;
    tail = head;
}
 
L2 :: ~L2()                                             // äåñòðóêòîð - îí è â àôðèêå äåñòðóêòîð
{
    
    makeEmpty();
}
 
L2 :: L2 (const L2 &List)                               // êîíñòðóêòîð êîïèðîâàíèÿ
{
    try
    {
        head = 0;
        tail = 0;
        L2_elem* temp = List.head;
 
        while (temp)
        {
            char c = temp->el;
            temp = temp->next;
            pushTail(c);
        }
    }
    catch (bad_alloc e)
    {
        makeEmpty();
        throw;      
    }
}
 
L2& L2::operator = (const L2& List)         // îïåðàòîð ïåðåãðóçêè
{
    makeEmpty();
    L2_elem* temp = List.head;
    while(temp)
    {
        char c = temp->el;              
        temp = temp->next;
        pushTail(c);
    }
    return *this;
}
 
void L2 :: pushHead (char c)                            // äîáàâèòü ýëåìåíò â íà÷àëî ñïèñêà
{
 
    {
        L2_elem* NewEl = new L2_elem(c,head,0); 
        if (isEmpty())
        {
            head = NewEl;
            tail = head;
        }
        else
        {
            NewEl->next = head;
            head->prev = NewEl;
            head = NewEl;
        }
    }
 
}
void L2 :: pushTail (char c)                            // äîáàâèòü ýëåìåíò â êîíåö ñïèñêà   
{   
        L2_elem* NewEl = new L2_elem(c,0,tail); 
        if ( isEmpty() )                                    // åñëè ñïèñîê ïóñò
        {
            tail = NewEl;                                   // äåëàåì íîâûé ýëåìåíò õâîñòîì
            head = tail;
        }
        else
        {
            NewEl->prev = tail;
            tail->next =  NewEl;
            tail = NewEl;
        }
}
 
L2_elem *L2::GetElemById(int i)
{
    L2_elem *p = (i<0?0:head); 
    for(int k = 0; k < i && p; k++)
    {
        p = p->next;
    } 
    return p;
}
 
void L2 :: AddAfter(char c, int i)
{
    if (i == 0)
    {
        pushHead(c);
        return;
    }
 
    L2_elem *p = GetElemById(i); 
    if(!p) { throw ListError(); }
 
    if (p == tail)
    {
        pushTail(c);
        return;
    }
    
    L2_elem* NewEl = new L2_elem(c,p->next,p); 
    NewEl->next->prev = NewEl;
    NewEl->prev->next = NewEl;
}
 
char L2 :: DelAfter(int i)              // óäàëèòü ýëåìåíò ïîñëå çàäàííîãî
{
    if (i == 0)
    {
        return popHead();       
    }
 
    L2_elem *p = GetElemById(i);
    if(!p) { throw ListError(); }
 
    if (p == tail)
    {
        return popTail();
    }
 
    char c = p->el;
    p->prev->next = p->next;
    p->next->prev = p->prev;
    delete p;
    return c;
}
 
char L2 :: popHead () 
{
    if ( isEmpty() ) 
    {
        throw ListError();
    }
    char c = head->el;    
    if ( head->next == 0 )                              // åñëè â ñïèñêå âñåãî 1 ýëåìåíò
    {
        delete head;                                    // óäàëÿåì åãî
        head = 0;                                       // è ãîâîðèì, ÷òî ñïèñîê ïóñò
        tail = 0;
    }
    else 
    {
        head = head->next;                              // ñäâèãàåì tail íà ïðåäûäóùèé ýëåìåíò
        delete  head->prev;                             // è óäàëÿåì ñòàðûé ïîñëåäíèé ýëåìåíò
        head->prev = 0;
    } 
    return c;
}
 
char L2 :: popTail () 
{
    if ( isEmpty() ) 
    {
        throw ListError(); 
    } 
    char c = tail->el;    
    if ( tail->prev == 0 )                              // åñëè â ñïèñêå âñåãî 1 ýëåìåíò
    {
        delete tail;                                    // óäàëÿåì åãî
        head = 0;                                       // è ãîâîðèì, ÷òî ñïèñîê ïóñò
        tail = 0;
        return c;
    }
    else 
    {
        tail = tail->prev;                              // ñäâèãàåì tail íà ïðåäûäóùèé ýëåìåíò
        delete ( tail->next );                          // è óäàëÿåì ñòàðûé ïîñëåäíèé ýëåìåíò
        tail->next = 0;
    } 
    return c;
}
 
 
 
 
int L2 :: size()const
{
    if (isEmpty())
    {
        return 0;
    }
    L2_elem* temp = head;
    int size = 0;
    while (temp)
    {       
        temp = temp->next;
        size++;
    }
    return size;
}
 
std::istream& operator>>(std::istream& i, L2& L)
{
    char c;
    cin >>c;
    L.pushHead(c);
    return i;   
}
 
std::ostream& operator<<(std::ostream& o, const L2& L) 
{
    L2_elem* temp = L.tail;
    while (temp)
    {
        o << temp->el << "\t";
        temp = temp->prev;
    }   
    return o;
}

#pragma once
struct ListError
{
    char* mem;
    char* empty;
};
int Readint();

#include <iostream>
#include "error.h"
using namespace std;
int Readint()
{
    unsigned int a;
    cin >> a;
    if (!cin)
    {
        cin.clear();
        while (cin.peek() !='\n')
            cin.ignore();
        cin.ignore();
    }
    return a;
}