Итератор для односвязного спика - C++ - Ответ 9655611

#include <iostream>
#include "s_list.h"
using namespace std;
 
int main()
{
 
    Single_list <int> list;
 
    for (int i = 0; i < 10; i++) 
        list.add_front(i);
 
    cout << (list.end() - list.begin())<<endl;
    
    system("pause");
}

template <class T>
class Single_list
{
 
    struct Single_node
    {
        Single_node *next;
        T val;
        Single_node() {}
        Single_node(T x) 
        {
            val = x;
        }
        Single_node(T x, Single_node* y) 
        {
            val = x; 
            next = y; 
        }
 
    };
 
    Single_node *head;
    Single_node *tail;
 
public:
    class iterator
    {
        Single_node* node;
    public:
        iterator(Single_node* tmp)
        {
            node = tmp;
        }
        T& operator*() 
        { 
            return node->val; 
        }
        iterator& operator++(int)
        {
            iterator it(node);
            node = node->next;
            return it;
        }
        iterator operator++()
        {
            node = node->next;
            return *this;
        }
        bool operator==( iterator& it) 
        { 
            return it.node == node; 
        }
        bool operator!=( iterator& it)
        { 
            return it.node != node;
        }
        iterator& operator+( int n)
        {
            for (int i = 0; i<n; ++i)
            {
                node = node->next;
            }
            return *this;
        }
        int operator-(iterator* q)
        {
            int counter = 0;
            for (Single_list::iterator p = this; p != q; p++)
            {
                counter++;
            }
            return counter;
        }
    };
    iterator begin()
    {
        return iterator(head); 
    }
    iterator end() 
    {
        return iterator(tail);
    }
    Single_list();
    Single_list(T);
    ~Single_list();
    bool is_empty();
    void add_front(T);
    int size();
    T remove_front();
    bool find(T);
    T get_nth(int);
};
 
template <class T> Single_list<T>::Single_list()
{
    head = new Single_node();
    tail = head;
}
 
template<class T> Single_list<T>::~Single_list()
{
    while (head != tail)
    {
        Single_node *temp;
        temp = head->next;
        delete head;
        head = temp;
    }
    delete head;
}
 
template <class T> void Single_list<T>::add_front(T x)
{
    head = new Single_node(x, head);
}
 
template <class T> bool Single_list<T>::is_empty()
{
    return head == tail;
}
 
template <class T>Single_list<T>::Single_list(T x)
{
    tail = new Single_node;
    head = new Single_node(x);
    head->next = tail;
}
 
template <class T> T Single_list<T>::remove_front()
{
    T temp_val = head->val;
    Single_node *temp_p = head;
    head = head->next;
    delete temp_p;
    return temp_val;
}
 
template <class T> bool Single_list<T>::find(T we_need)
{
    Single_node *current = head;
    while (current != tail)
        if (current->val == we_need)
            return true;
        else current = current->next;
        return false;
}
 
template <class T> T Single_list<T>::get_nth(int n)
{
    Single_node *current = head;
    for (int i = 0; i<n; i++)
        current = current->next;
    return current->val;
}
 
template <class T> int Single_list<T>::size()
{
    Single_node *current = head;
    int sz = 0;
    while (current != tail)
    {
        current = current->next;
        sz++;
    }
    return sz;
}