Итератор для контейнера

#include <iostream>
 
template <class node, class T>
class iterator
{
public:
 
    iterator(node* n)
    : node_ptr(n)
    {
    }
 
    T* operator * ()
    {
        return node_ptr->get();
    }
 
    T* operator -> ()
    {
        return node_ptr->get();
    }
 
    void operator ++ ()
    {
        node_ptr = node_ptr->next();
    }
 
    iterator operator ++ (int)
    {
        iterator iter(*this);
        ++(*this);
        return iter;
    }
 
    bool operator == (iterator const& i)
    {
        return node_ptr == i.node_ptr;
    }
 
    bool operator != (iterator const& i)
    {
        return !(*this == i);
    }
 
private:
 
    node* node_ptr;
};
 
template <class T>
class list_node
{
public:
 
    list_node(T const& t)
    : object(t)
    , next_node(0)
    {
        
    }
 
    ~list_node()
    {
        delete next_node;
    }
 
    void push_back(T const& t)
    {
        if(next_node)
        {
            next_node->push_back(t);
        }
        else
        {
            next_node = new list_node(t);
        }
    }
 
    list_node* next()
    {
        return next_node;
    }
 
    T* get()
    {
        return &object;
    }
 
private:
 
    T object;
    list_node* next_node;
};
 
template <class T>
class list
{
public:
 
    typedef list_node<T> node;
 
    typedef iterator<node, T> iterator;
 
    list()
    : root(0)
    {
    }
 
    ~list()
    {
        delete root;
    }
 
    void push_back(T const& t)
    {
        if(root)
        {
            root->push_back(t);
        }
        else
        {
            root = new node(t);
        }
    }
 
    iterator begin()
    {
        return iterator(root);
    }
 
    iterator end()
    {
        return iterator(0);
    }
 
private:
 
    node* root;
};
 
int main()
{
    typedef list<std::string> string_container;
    string_container orders;
 
    orders.push_back("First");
    orders.push_back("Second");
    orders.push_back("Third");
    orders.push_back("Fourth");
 
    for(string_container::iterator it = orders.begin(); it != orders.end(); ++it)
    {
        std::cout << it->c_str() << std::endl;
    }
 
    return 0;
}

class link
{
public:
    shapes* value;
    link* next;
 
    link();
    ~link();
};
 
class queue
{
protected:
    link* head; //указатель на начало очереди
    link* tail; //указатель на конец очереди
    link* cur; //вспомогательный указатель на текущий эл в очереди
    
public:
    void enqueue(shapes *s); //добавить элемент (в конец списка)
    void dequeue(); //удалить элемент (из начала списка)
    void printCont();   //вывод содержимого контейнера
 
    queue();
    ~queue();
};

link::link()
{
    value=0;
    next=0;
};
 
link::~link()
{};
 
 
 
queue::queue()
{
    head=new link;
    tail=new link;
};
 
queue::~queue()
{};
 
void queue::enqueue(shapes* s) //добавить элемент (в конец списка)
{
    if (head->next==0) 
    {
        cur=new link; //используется однажды,
        head->next=cur; //когда добавляется 1-й элемент
    }
    else
    {
        cur->next=new link;
        cur=cur->next; //осуществляется сцепление элементов
    }
 
    cur->value=s;
    cur->next=cur; //излишне (но и не помешает) -- последний элемент указывает сам на себя
    tail->next=cur; //сохраняем адрес посл. эл. в контейнере
 
    cout<<"Добавлен элемент: ";
    cur->value->info();
    cout<<endl;
    
};
 
void queue::dequeue() //удалить элемент (из начала списка)
{
    link* dCur;
 
    dCur=head->next;
    if (dCur==0)
        cout<<"Контейнер пуст!"<<endl;
    else
    {
        if (dCur==dCur->next) //последний элемент, который будет удален
        {
            head->next=0;
            cout<<"Контейнер опустел."<<endl;
        }
        else //удаляется не последний элемент
            head->next=dCur->next;
 
        delete dCur;
    }
};
 
void queue::printCont() //вывести элементы
{
    link* pCur;
    if (head->next==0)
        cout<<"Контейнер пуст!"<<endl;
    else
    {
        pCur=head->next;
        while (pCur!=tail->next)
        {
            pCur->value->info();
            cout<<" ";
            pCur=pCur->next;
        }
 
        pCur->value->info(); //вывод последнего эл.
    }
};