Переделать двусвязный список в двусвязный кольцевой

#include <iostream>
 
using namespace std;
 
template <class T>
class List 
{
    private:
       class Node 
       { 
           public:
                Node *next;                     
                Node *prev;             
                T val;                   
            
                Node(T node_val) : val(node_val) { }        
                Node() { }                                  
 
                ~Node() { }                                 
 
           void print_val( ) { cout << val << " "; }
        };
 
    public:
        class Iterator 
        {
            private:
                friend class List<T>;
                Node *t_node;
            public:
                Iterator( ) : t_node(0) { }
                Iterator(Node * dn) : t_node(dn) { }
 
                Iterator(const Iterator & it) : t_node(it.t_node) { }
                
                Iterator& operator=(const Iterator& it) 
                { 
                  t_node = it.t_node;
                  return *this;
                 }
                
                bool operator==(const Iterator& it) const 
                { 
                    return (t_node == it.t_node); 
                }
 
                bool operator!=(const Iterator& it) const 
                { 
                    return !(it == *this); 
                }
 
                Iterator& operator++( ) 
                { 
                    if ( t_node == 0 )
                        throw "incremented an empty Iterator";
                    if ( t_node->next == 0 )
                        throw "tried to increment too far past the end";
                    t_node = t_node->next;
                    
                    return *this;
                }
 
                Iterator& operator--( ) 
                { 
                    if ( t_node == 0 )
                        throw "decremented an empty Iterator";
                    if ( t_node->prev == 0 )
                        throw "tried to decrement past the beginning";
                    t_node = t_node->prev;
 
                    return *this;
                }
 
                T& operator*( ) const 
                {
                    if ( t_node == 0 )
                        throw "tried to dereference an empty Iterator";
                
                    return t_node->val;
                }
         };
 
    private:
        Node *head;      
        Node *tail;       
        List & operator=(const List &);
        List(const List &);
        
        Iterator head_iterator;
        Iterator tail_iterator;
    
    public:
        List( ) 
        {  
            head = tail = new Node;
            tail->next = 0;
            tail->prev = 0;
            head_iterator = Iterator(head);
            tail_iterator = Iterator(tail);
        }
 
        List(T node_val) 
        { 
            head = tail = new Node;
            tail->next = 0;         
            tail->prev = 0;
            head_iterator = Iterator(head);
            tail_iterator = Iterator(tail);
            add_front(node_val);
        }
 
        ~List( )  
        {  
            Node *node_to_delete = head;
            
            for (Node *sn = head; sn != tail;) 
            { 
                sn = sn->next;
                delete node_to_delete;
                node_to_delete = sn;
            }
            
            delete node_to_delete;
        }
 
        bool is_empty( ) 
        {
            return head == tail;
        }
 
        Iterator front( ) 
        { 
            return head_iterator; 
        }
 
        Iterator rear( )  
        { 
            return tail_iterator; 
        }
 
        void add_front(T node_val)  
        { 
                Node *node_to_add = new Node(node_val);
                node_to_add->next = head;
                node_to_add->prev = 0;
                head->prev = node_to_add;
                head = node_to_add;
                head_iterator = Iterator(head);
        }
 
 
        bool remove_it(Iterator & key_i)  
        {  
            for ( Node *dn = head; dn != tail; dn = dn->next ) 
                if ( dn == key_i.t_node )     
                { 
                    dn->prev->next = dn->next;
                    dn->next->prev = dn->prev;
                    delete dn;                             
                    key_i.t_node = 0;
                    
                    return true;
                }
                
                return false;
        }
 
 
        Iterator find(T node_val) const 
        {   
            for ( Node *dn = head; dn != tail; dn = dn->next ) 
                if ( dn->val == node_val ) return Iterator(dn);
                    return tail_iterator;
        }
 
        int size( ) const 
        {  
            int count = 0;
            for ( Node *dn = head; dn != tail; dn = dn->next ) 
                count++;
            return count;
        }
 
        void print( ) const 
        {    
            for ( Node *dn = head; dn != tail; dn = dn->next ) 
                dn->print_val( );
            cout << endl;
        }
};

#include "stdafx.h"
#include "list.h"
 
List<int> the_list;                 
 
int main()
{ 
    int ret  = 0;
    List<int>::Iterator list_iter;
 
    for (int j = 9; j > 1; --j) 
        the_list.add_front(j*j-j);
 
    the_list.print( );
 
    //реверс і на екран
    for ( list_iter = the_list.rear( ) ; list_iter != the_list.front( ) ; )
    {   
        --list_iter;
        cout << *list_iter << " ";
    }
    cout << endl;
 
    the_list.remove_it(the_list.find(72));
 
 
     for ( list_iter = the_list.front( ); list_iter != the_list.rear( ); ++list_iter ) 
          cout << *list_iter << " ";
 
    cout << endl;
 
    cout<<the_list.size( )<<endl;
 
    the_list.add_front(1);
 
 
    the_list.print( );
    
    system("pause");
    
    return 0;
}