STL & Overloading in C++ - c++

Question

I've created a doubly-linked list out of nodes. I'm working with the STL. I'm getting an error in the operator++ function. Here's my Iterator<T> class.
#include "Node.h"
#include <iostream>
using namespace std;
template<class T> class Iterator{
public:
Iterator();
~Iterator();
Node<T> *node;
void operator++(Iterator<T> val);
void operator--();
T operator*();
private:
};
template<class T>
Iterator<T>::Iterator(){
node = 0;
}
template<class T>
Iterator<T>::~Iterator(){
}
template<class T>
void Iterator<T>::operator++(Iterator<T> val){
if(node != 0){
node = node->next;
}
}
template<class T>
void Iterator<T>::operator--(){
if(node != 0)
node = node->prev;
}
template<class T>
T Iterator<T>::operator*(){
if(node == 0){
cout << "Node no exists!";
}
else{
return node->value;
}
}
I'm also getting a warning in my main function.
#include <iostream>
#include "List.h"
using namespace std;
int main()
{
List<int> mylist;
for(int i = 2; i < 10; i++){
mylist.push_back(i);
}
Iterator<int> it = mylist.begin();
while(it.node->next != 0){
cout << it.node->value << "\n";
it++;
}
mylist.pop_front();
cout << mylist.front() << ", ";
cout << mylist.back();
return 0;
}
ERRORS AND WARNINGS
F:\New folder\C++\Lab14\Iterator.h||In instantiation of 'class
Iterator':|
F:\New folder\C++\Lab14\main.cpp|15|required from here|
F:\New folder\C++\Lab14\Iterator.h|29|error: postfix 'void
Iterator::operator++ (Iterator) [with T = int]' must take 'int'
as its argument|
F:\New folder\C++\Lab14\main.cpp||In function 'int main()':|
F:\New folder\C++\Lab14\main.cpp|19|error: no 'operator++(int)'
declared for postfix '++' [-fpermissive]|
By the way, I'm planing to do the same with the other operators too. The operator* is not for multiplication.

Answer 1

operator++ must either take a single int or no argument:
void operator++(int);
void operator++();
The first is the overload for postfix ++ and the second for prefix ++. The int argument is only to allow the correct overload to occur; its value is unspecified.
Your declaration of operator++ currently looks like this:
void operator++(Iterator<T> val);
It seems like you're expecting the object that is being incremented to be passed as an argument. Actually, the object is the object pointed to by this. You would implement your operator++ like so:
template<class T>
Iterator<T> Iterator<T>::operator++(int) {
Iterator<T> copy = *this;
if(node != 0) {
node = node->next;
}
return copy;
}
Note that I've also returned a copy of the object before changing its node member. This is usually expected of a postfix increment operator.
To get prefix increment, overload with no argument. It should return *this by reference. ie.
Iterator operator++(int); // postfix
Iterator & operator++(); // prefix

Answer 2

Like most operators, there are two ways you can define operator++. You can write it as a member of the iterator class, or as a free function. But there's another complication, because there are two forms of operator++: prefix and postfix. So writing that operator takes a bit more thought.
As a member:
struct Iterator {
Iterator& operator++(); // prefix
Iterator operator++(int); // postfix
};
As a free function:
struct Iterator { };
Iterator& operator++(Iterator&); // prefix
Iterator operator++(Iterator&, int); // postfix

Answer 3

operator++ shouldn't take an argument. Removing the argument from both the prototype and definition should fix your error.
And just as a little 'pointer' (get it?), the dereference operator probably should return a node<T>, not T. (You can do both, but the former makes more sense, and would make it behave in a similar way to std containers.)