Operator = not recognized - c++

Question

I've tried to make a class List, with iterator:
#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()
{
Iterator<T> result;
result.ptr=node->next;
return result;
}
Iterator<T> last()
{
Iterator<T> result;
result.ptr=node->prev;
return result;
}
Iterator<T> end()
{
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)
{
Iterator<T> i=l.begin();
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!= (Iterator<R>& i, Iterator<R>& j);
template<class R>
friend bool operator== (Iterator<R>& i, Iterator<R>& j);
};
template <class T>
bool operator!= (Iterator<T>& i, Iterator<T>& j)
{
return i.ptr!=j.ptr;
}
template <class T>
bool operator== (Iterator<T>& i, Iterator<T>& j)
{
return i.ptr==j.ptr;
}
}
#endif
But I get these errors:
/home/ramy/Documents/C++/Prova/Util.h||In function ‘std::ostream& Util::operator<<(std::ostream&, const Util::List<T>&) [with T = int]’:|
/home/ramy/Documents/C++/Prova/main.cpp|11|instantiated from here|
/home/ramy/Documents/C++/Prova/Util.h|218|error: passing ‘const Util::List<int>’ as ‘this’ argument of ‘Util::Iterator<T> Util::List<T>::begin() [with T = int]’ discards qualifiers|
||=== Build finished: 1 errors, 0 warnings ===|
With this main:
#include <iostream>
#include "Util.h"
using namespace Util;
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 don't why I get this error, it seems like the operator = is not considered right.
It sounds absurd to me, but of course there will be an explanation.

Answer 1

you need a
ConstIterator<T> List<T>::begin() const;
// ^^^^^
With a corresponding ConstIterator type so that the list in Util::operator<< can actually iterate over that list. non-const member functions cannot be used on const references, even if the referent is itself non-const.
While you're at it, you should probably define a pile of other const member functions for List<T>

Answer 2

Looks like you're calling non-const method (begin()) on a const object.