I'm trying to create an iterator class as a member-class for a list class, and am trying to overload the indirection operator (*) to access the list it's pointing to:
template<class T>
T list<T>::iterator::operator*(iterator& iter)
{
return ((iter.lstptr)->current)->data;
}
where lstptr
is a pointer to a list, current
is a pointer to a node class, and the node class contains the data member data
of type T
.
Iterator is declared like this:
template<class T>
class list
{
public:
class iterator;
};
template<class T>
class list<T>::iterator
{
//stuff
};
I am able to compile the function definition of the overloaded operator* fine, but when I try to do something like:
list<int> lst1;
lst1.add(6);
list<int>::iterator IT;
IT = lst1;
//everything above this point compiles fine
int a = *IT; //error here (line fourteen)
The error I get says <1> that I am using an illegal indirection, and <2> that it cannot convert from list::iterator to int. Both errors occur on line fourteen.
Does anybody know what I am doing wrong and how I can overload the indirection operator correctly?
NB: If you need to see more code, tell me which part, because I don't want to put th entire code up here because it's abot 205 lines, and 204 of those lines don't (I think) have any errors.
You overloaded the multiply operator. Take the parameter out to make it an indirection operator.
You should also have it return a reference if you want code like
*IT = 3;
to compile.You have two problems here; the first is that you have accidentally overloaded the multiplication operator and not the dereferencing operator; the second is that you haven't returned a reference type.
The first issue comes about as a result of the number of parameters. Every non-static member function of a class has an additional "hidden" parameter:
this
.this
is, of course, the pointer to the object the function is being invoked on. As a result, you have actually declared a version of the operator taking two parameters. By removing the second iterator parameter and operating onthis
, you will be overloading the unary*
and not the binary one.The second issue is a minor one of return type; you are returning a copy to the original object and not the original object itself. Declare the return type as
T&
to return a reference.