СД Двунаправленный список

#ifndef LISTNODE_H
#define LISTNODE_H
 
template< typename T > class List;
 
template< typename T >
class ListNode
{
    friend class List< T >;
 
public:
    ListNode();
    ListNode(const T &);
 
    T get_data() const;
 
private:
    T _data;
    ListNode< T > *_next;
};
 
template< typename T >
ListNode< T >::ListNode():
_next(0)
{
}
 
template< typename T >
ListNode< T >::ListNode(const T &data):
_data(data),
_next(0)
{
}
 
template< typename T >
T ListNode< T >::get_data() const
{
    return _data;
}
 
#endif

#ifndef LIST_H
#define LIST_H
 
#include <iostream>
 
#include "ListNode.h"
 
template< typename T >
class List
{
public:
    List();
    List(const List< T > &);
    ~List();
 
    bool is_empty() const;
 
    void insert(const T &);
    void insert_front(const T &);
    void insert_back(const T &);
 
    bool remove_front(T &);
    bool remove_back(T &);
 
    bool front(T &) const;
    bool back(T &) const;
 
    void print() const;
 
private:
    ListNode< T > *_first;
    ListNode< T > *_last;
};
 
template< typename T >
List< T >::List():
_first(0),
_last(0)
{
}
 
template< typename T >
List< T >::List(const List< T > &original):
_first(0),
_last(0)
{
    ListNode< T > *i = original._first;
 
    while (i != 0)
    {
        insert_back(i->_data);
        i = i->_next;
    }
}
 
template< typename T >
List< T >::~List()
{
    if (!is_empty())
    {
        ListNode< T > *i = _first;
        ListNode< T > *del_elem;
 
        while (i != 0)
        {
            del_elem = i;
 
            i = i->_next;
 
            delete del_elem;
        }
    }
}
 
template< typename T >
bool List< T >::is_empty() const
{
    return _first == 0;
}
 
template< typename T >
void List< T >::insert(const T &data)
{
    ListNode< T > *new_elem = new ListNode< T > (data);
    
    if (is_empty())
    {
        _first = new_elem;
        _last = new_elem;
    }
    else
    {
        if (_first->_data >= data)
        {
            new_elem->_next = _first;
            _first = new_elem;
 
            return;
        }
        else
        {
            if (_last->_data <= data)
            {
                _last->_next = new_elem;
                _last = new_elem;
 
                return;
            }
        }
 
        ListNode< T > *i = _first;
 
        while (i != 0)
        {
            if (i->_next->_data >= data)
            {
                new_elem->_next = i->_next;
                i->_next = new_elem;
 
                break;
            }
 
            i = i->_next;
        }
    }
}
 
template< typename T >
void List< T >::insert_front(const T &data)
{
    ListNode< T > *new_elem = new ListNode< T > (data);
 
    if (is_empty())
    {
        _first = new_elem;
        _last = new_elem;
    }
    else
    {
        new_elem->_next = _first;
        _first = new_elem;
    }
}
 
template< typename T >
void List< T >::insert_back(const T &data)
{
    ListNode< T > *new_elem = new ListNode< T > (data);
 
    if (is_empty())
    {
        _first = new_elem;
        _last = new_elem;
    }
    else
    {
        _last->_next = new_elem;
        _last = new_elem;
    }
}
 
template< typename T >
bool List< T >::remove_front(T &data)
{
    if (!is_empty())
    {
        ListNode< T > *del_elem = _first;
 
        data = _first->_data;
 
        if (_first == _last)
        {
            _first = 0;
            _last = 0;
        }
        else
            _first = _first->_next;
 
        delete del_elem;
 
        return true;
    }
    else
        return false;
}
 
template< typename T >
bool List< T >::remove_back(T &data)
{
    if (!is_empty())
    {        
        ListNode< T > *del_elem = _last;
 
        data = _last->_data;
 
        if (_first == _last)
        {
            _first = 0;
            _last = 0;
        }
        else
        {
            ListNode< T > *i = _first;
 
            while (i->_next != _last)
                i = i->_next;
 
            _last = i;
            _last->_next = 0;
        }
 
        delete del_elem;
 
        return true;
    }
    else
        return false;
}
 
template< typename T >
bool List< T >::front(T &data) const
{
    if (!is_empty())
    {
        data = _first->_data;
 
        return true;
    }
    else
        return false;
}
 
template< typename T >
bool List< T >::back(T &data) const
{
    if (!is_empty())
    {        
        data = _last->_data;
 
        return true;
    }
    else
        return false;
}
 
template< typename T >
void List< T >::print() const
{
    if (!is_empty())
    {
        ListNode< T > *i = _first;
 
        std::cout << i->_data;
 
        i = i->_next;
 
        while (i != 0)
        {
            std::cout << " -> " << i->_data;
 
            i = i->_next;
        }
    }
    else
        std::cout << "List is empty";
 
    std::cout << std::endl;
}
 
#endif