Belov_LW_O6

#include <iostream>
using namespace std;

template <class T>
struct Elem
{
    T data; // данные
    Elem* next, * prev;
};

template <class T>
class List
{
    Elem<T>* Head, * Tail;
    int _size;
    Elem<T>* getElem(int pos);
public:
    List();
    List(const List&);
    ~List();

    int size()const;

    void clear();
    T pop(int pos);
    T popTail();
    void swap(int pos1, int pos2);

    void pushTail(T n);
    void pushHead(T n);

};

template<class T>
inline Elem<T>* List<T>::getElem(int pos)
{
    Elem<T>* temp = Head;

    if (pos < 1 || pos > _size)
    {
        cout << "Incorrect position !!!\n";
        return 0;
    }

    int i = 1;
    while (i < pos && temp != 0)
    {
        temp = temp->next;
        i++;
    }

    if (temp == 0)
        return 0;
    else
        return temp;
}

template <class T>
List<T>::List()
{
    Head = Tail = NULL;
    _size = 0;
}

template <class T>
List<T>::List(const List& L)
{
    Head = Tail = NULL;
    _size = 0;

    Elem<T>* temp = L.Head;
    while (temp != 0)
    {
        pushTail(temp->data);
        temp = temp->next;
    }
}

template <class T>
List<T>::~List()
{
    clear();
}

template <class T>
void List<T>::pushHead(T n)
{
    Elem<T>* temp = new Elem<T>;
    temp->prev = 0;
    temp->data = n;
    temp->next = Head;

    if (Head != 0)
        Head->prev = temp;
    if (_size == 0)
        Head = Tail = temp;
    else
        Head = temp;
    _size++;
}

template <class T>
void List<T>::pushTail(T n)
{
    Elem<T>* temp = new Elem<T>;
    temp->next = 0;
    temp->data = n;
    temp->prev = Tail;

    if (Tail != 0)
        Tail->next = temp;
    if (_size == 0)
        Head = Tail = temp;
    else
        Tail = temp;
    _size++;
}

template <class T>
T List<T>::pop(int pos)
{
    if (pos < 1 || pos > _size)
    {
        cout << "Incorrect position !!!\n";
        return T();
    }

    int i = 1;

    Elem<T>* Del = Head;

    while (i < pos)
    {
        Del = Del->next;
        i++;
    }

    Elem<T>* PrevDel = Del->prev;
    Elem<T>* AfterDel = Del->next;
    if (PrevDel != 0 && _size != 1)
        PrevDel->next = AfterDel;
    if (AfterDel != 0 && _size != 1)
        AfterDel->prev = PrevDel;
    if (pos == 1)
        Head = AfterDel;
    if (pos == _size)
        Tail = PrevDel;
    T val = Del->data;
    delete Del;
    _size--;

    return val;
}

template<class T>
inline T List<T>::popTail()
{
    if (_size == 0) return T();
    if (_size == 1)
    {
        T val = Tail->data;
        delete Tail;
        Tail = Head = nullptr;
        _size--;
        return val;
    }
    else
    {
        Elem<T>* del = Tail;
        T val = Tail->data;
        Tail->prev->next = nullptr;
        Tail = Tail->prev;
        delete del;
        _size--;
        return val;
    }
}

template<class T>
inline void List<T>::swap(int pos1, int pos2)
{
    Elem<T>* temp1 = getElem(pos1);
    Elem<T>* temp2 = getElem(pos2);
    T temp_val = temp1->data;
    temp1->data = temp2->data;
    temp2->data = temp_val;
}

template <class T>
void List<T>::clear()
{
    while (_size != 0)
        pop(1);
}

template <class T>
int List<T>::size()const
{
    return _size;
}