Lista dwukierunkowa cykliczna, iterator

Witam, mam do zrobienia cykliczną listę dwukierunkową. Rozumiem, że ma ona tylko jedno wejście ( u mnie nazywa się "any" ), oraz każdy element listy ma wskaźnik na poprzedni i następny. Może ktoś zerknąć czy dobrze wykonałem tą listę? Mam wrażenie, że any powinno być randomowo przydzielane ( tak zrozumiałem z wykładu) ale nie do końca wiem jak to zrobić. Do tego, czy jak dodaje pierwszy element to on ma wskazywać sam na siebie?

KOD:

#include <iostream>
#include <string>

template<typename K, typename I>
class Ring{
    struct node{
        K key;
        I inf;
        node *next;
        node *prev;
    };
    node *any;
    public:
    Ring();
    ~Ring();
    void print_list();

    void remove_element(K which);
    void add_after(K after, K ke, I in);
    bool exist(K ke);
    node* create_node(K ke, I in);

};
using namespace std;
//MAIN!



int main()
{
    Ring<int, int> test;
    /*test.add_after(1,2,3);
    test.add_after(2,3,5);
    test.add_after(7,4,3);
    test.add_after(0,5,5);
    test.add_after(5,4,2);
    test.remove_element(10);*/
    test.print_list();
    return 0;
}





template<typename K, typename I>
Ring<K,I>::Ring()
{
    any=0;


}

template<typename K, typename I>
Ring<K,I>::~Ring()
{
    node *ptr=any;
    cout<<"Destructor in the mix!"<<endl;
    if(any!=0)
    do{
        ptr=any;
        any=any->next;
        delete ptr;
        ptr=any;
    }while(ptr!=any);
    else
        delete any;
}

template<typename K, typename I>
typename Ring<K,I>::node* Ring<K,I>::create_node(K ke, I in)
{
    node *temp=new(struct node);
    temp->next=0;
    temp->prev=0;
    temp->key=ke;
    temp->inf=in;
    return temp;
}

template<typename K, typename I>
void Ring<K,I>::add_after(K after, K ke, I in)
{
    if(exist(ke))
    {
        cout<<"there is already element with key: "<<ke<<endl;
        return;
    }
    node *ptr=any;
    node *new_one=create_node(ke,in);
    if(any==0)//empty list;/
    {
        any=new_one;
        any->next=any->prev=any;
    }else{
        if(any->key==after)
        {
            node *x=any->next;
            x->prev=new_one;
            new_one->next=any->next;
            new_one->prev=any;
            any->next=new_one;
        }else{
            do{
                ptr=ptr->next;
            }while(ptr!=any &&ptr->key!=after);
                node *x=ptr->next;
                x->prev=new_one;
                new_one->next=ptr->next;
                new_one->prev=ptr;
                ptr->next=new_one;
        }
    }
}

template<typename K, typename I>
void Ring<K,I>::print_list()
{
    node *ptr=any;
    if(any==0)
    {
        cout<<"List is EMPTY!"<<endl;
        return;
    }
    do{
        cout<<"Key:  "<<ptr->key<<"  Inf:  "<<ptr->inf<<endl;
        ptr=ptr->next;
    }while(ptr!=any);
}

template<typename K, typename I>
void Ring<K,I>::remove_element(K which)
{
    node *ptrprev=any->prev;
    node *ptr=any;
    if(any==0)
    {
        cout<<"List is empty!"<<endl;
        return;
    }
    do{
        ptr=ptr->next;
        ptrprev=ptrprev->next;
    }while(ptr!=any && ptr->key!=which);
    if(ptr->key==which)
    {
        any=ptr->next;
        ptrprev->next=any;
        any->prev=ptrprev;
        delete ptr;
    }else
    cout<<"there is no such element!"<<endl;

}

template<typename K, typename I>
bool Ring<K,I>::exist(K ke)
{
    if(any==0)
        return false;
    node *ptr;
    ptr=any;
    do{
        if(ptr->key==ke){
            return true;
        }
        ptr=ptr->next;
    }while(ptr!=any);
    return false;
}

Muszę również zrobić do tego class iterator, ale nie bardzo wiem do czego ma służyć i jak wyglądać, więc jakby ktoś mógł w 2-3 zdaniach wytłumaczyć na czym ma polegać to będę wdzięczny.

1. Wygląda na to że w takiej liście jeżeli jest jeden element to wskazuje on sam na siebie (chociaż to pewnie bez większego znaczenia).
2. Element any to jednocześnie początek i koniec kolejki żeby iterując po kolejnych węzłach wiedzieć gdzie się zatrzymać, najsensowniejsze wydaje się oznaczenie jako any pierwszego dodanego elementu a jeżeli go usuniesz wybrać jakikolwiek inny z dostępnych.
3. Ten class iterator to pewnie "wskaźnik" na elementy listy pokazujący na dany węzeł i który można przesuwać analogicznie do iter++ lub iter += 1; http://en.cppreference.com/w/cpp/concept/Iterator.