Question

I have a class List:

#ifndef UTIL_H
#define UTIL_H

#include <iostream>
#include <exception>

namespace Util
{

class IndexOutOfBounds : public std::exception
{
    virtual const char* what()
    {
        return "Index out of bounds";
    }
};

template<class T>
class Iterator;

template <class T>
class ListNode
{

    template<class R>
    friend class Iterator;
    template<class R>
    friend class List;

    public:

    ListNode()
    {
        init();
    }
    ListNode(T info)
    {
        init();
        this->info=info;
    }
    static void link(ListNode<T> first, ListNode<T> second)
    {
        first.next=&second;
        second.prev=&first;
    }
    template<class R>
    friend std::ostream& operator<< (std::ostream& out, const ListNode<R>& node);
    template<class R>
    friend std::istream& operator>> (std::istream& in, const ListNode<R>& node);

    private:

    T info;
    ListNode<T>* next;
    ListNode<T>* prev;
    void init()
    {
        next=prev=this;
    }
};

template<class T>
std::ostream& operator<< (std::ostream& out , const ListNode<T>& node)
{
    out << node.info;
    return out;
}

template<class T>
std::istream& operator>> (std::istream& in , const ListNode<T>& node)
{
    in >> node.info;
    return in;
}

template <class T>
class List
{
    friend class ListNode<T>;
    template <class R>
    friend class Iterator;
    private:

    unsigned int length;
    ListNode<T>* node;

    public:

    List()
    {
        node=new ListNode<T>();
        length=0;
    }
    unsigned int size() const
    {
        return length;
    }
    void insert(int i,T info) throw()
    {
        ListNode<T>* ptr=node,*next_ptr;
        try
        {
            if(i>(int)length || i<0)
                throw IndexOutOfBounds();
            for(int j=0;j<i;j++)
                ptr=ptr->next;
            next_ptr=ptr->next;
            ptr->next=new ListNode<T>(info);
            ptr->next->prev=ptr;
            ListNode<T>::link(*(ptr->next),*next_ptr);
            length++;
        }
        catch(IndexOutOfBounds& e)
        {
            throw e;
        }
    }
    void push_back(T info) throw()
    {
        try
        {
            insert(length,info);
        }
        catch(IndexOutOfBounds& e)
        {
            throw e;
        }
    }
    void push_front(T info) throw()
    {
        try
        {
            insert(0,info);
        }
        catch(IndexOutOfBounds& e)
        {
            throw e;
        }
    }
    void remove(int i) throw()
    {
        ListNode<T>* ptr=node,*next_ptr;
        try
        {
            if(i>=length || i<0)
                throw IndexOutOfBounds();
            for(int j=0;j<i;j++)
                ptr=ptr->next;
            next_ptr=ptr->next->next;
            delete ptr->next;
            ListNode<T>::link(*ptr,*next_ptr);
            length--;
        }
        catch(IndexOutOfBounds& e)
        {
            throw e;
        }
    }
    void pop_back() throw()
    {
        try
        {
            remove(length-1);
        }
        catch(IndexOutOfBounds& e)
        {
            throw e;
        }
    }
    void pop_front() throw()
    {
        try
        {
            remove(0);
        }
        catch(IndexOutOfBounds& e)
        {
            throw e;
        }
    }
    Iterator<T> begin() const
    {
        Iterator<T> result;
        result.ptr=node->next;
        return result;
    }
    Iterator<T> last() const
    {
        Iterator<T> result;
        result.ptr=node->prev;
        return result;
    }
    Iterator<T> end() const
    {
        Iterator<T> result;
        result.ptr=node;
        return result;
    }
    template <class R>
    friend std::ostream& operator<< (std::ostream& out , const List<R>& l) ;
    template <class R>
    friend std::istream& operator>> (std::istream& in , const List<R>& l);
    typedef Iterator<T> iterator;

};

template<class T>
std::ostream& operator<< (std::ostream& out ,const List<T>& l)
{
    int k=0;
    for(Iterator<T> i=l.begin();i!=l.end();++i)
        out << *i << "\t";
    return out;
}

template<class T>
std::istream& operator>> (std::istream& in , const List<T>& l)
{
    for(Iterator<T> i=l.begin();i!=l.end();i++)
        in >> *i;
    return in;
}

template <class T>
class Iterator
{
    friend class List<T>;
    friend class ListNode<T>;
    private:

    ListNode<T>* ptr;

    public:

    Iterator()
    {
        ptr=NULL;
    }
    Iterator(const Iterator<T>& i)
    {
        ptr=i.ptr;
    }
    Iterator<T>& operator= (Iterator<T> i)
    {
        ptr=i.ptr;
        return *this;
    }
    Iterator<T>& operator++ ()
    {
        ptr=ptr->next;
        return *this;
    }
    Iterator<T> operator++ (int)
    {
        Iterator<T> i=*this;
        ++*this;
        return i;
    }
    Iterator<T>& operator-- ()
    {
        ptr=ptr->prev;
        return *this;
    }
    Iterator<T> operator-- (int)
    {
        Iterator<T> i=*this;
        --*this;
        return i;
    }
    T& operator* ()
    {
        return ptr->info;
    }
    template<class R>
    friend bool operator!= (const Iterator<R>& i, const Iterator<R>& j);
    template<class R>
    friend bool operator== (const Iterator<R>& i, const Iterator<R>& j);

};

template <class T>
bool operator!= (const Iterator<T>& i, const Iterator<T>& j)
{
    return i.ptr!=j.ptr;
}

template <class T>
bool operator== (const Iterator<T>& i, const Iterator<T>& j)
{
    return i.ptr==j.ptr;
}

}

#endif

If in the main I try to print it:

int main(int argc, char** argv)
{
List<int> l;
for(int i=0;i<10;i++)
    l.push_back(i);
std::cout << l;
return 0;
}

I get the screen full of numbers flowing, I have to kill the process from terminal.
So it goes into ain infinite loop and I don’t understand why.
Maybe the Iterator operator != has some issue, I don’t understand.

Answer 1

You don’t terminate your linked list, in the last node the next pointer points back to the element itself.

Either fix this in the ListNode constructor (preferred), or when inserting new element to the list.