Overloading the increment operator for an iterator class

Question

I've been attempting to overload the ++ operator to move an iterator through a list, but I keep getting Error C2460 'List::Iterator::++': uses 'List::Iterator'

template <typename E>
class List : public SLinkedList<E> {

public:
// NOTE THE DIFFERENT LETTER – IT IS ONLY USED HERE! 
// Use E everywhere else! m
// For a nested class, methods are declared and defined *INSIDE*
// the class declaration.
template <typename I>
class Iterator {
public:
    // Give List access to Iterator private fields.
    friend class List<E>;

    // These are the minimum methods needed.
    E operator* {nodePosition->elem}; //dereference the iterator and return a value
    Iterator<E> operator++ {nodePosition = nodePosition->next};  //increment the iterator
    Iterator<E> operator-- {
        nodePosition = nodePosition->prev;
    }  //decrement the iterator
    bool operator==(const Iterator<E> p)  { 
        return (nodePosition == p)
    }  //test equality of iterators
    bool operator!=(const Iterator<E> p) {
        return (nodePosition != p)
    }   //test inequality of iterators


private:
    // Constructors & destructor here since only want List class to access.

    // List constructor called from List::begin(). Use initializer list or
    // create class copy constructor and assignment overload.
    Iterator(const List<E>* sl) : llist(sl) {
        nodePosition = sl->head;
    }

    // Class fields.
    const List<E>* llist;     //give Iterator class a handle to the list
    Node<E>* nodePosition;  //abstracted position is a pointer to a node

}; /** end Iterator class **/

   /* The Iterator class is now fully defined. The rest of these
   statements must go AFTER the Iterator class or the compiler
   won’t have complete information about their data types.
   */

   // REQUIRED: While not necessary for the code to work, my test suite needs
   // this defined. Create a less cumbersome name for Iterator<E>. Use 
   // anywhere you would have used List<E>::Iterator<E> in class List. Allows 
   // this syntax in main() -- List<int>::iterator instead of List<int>::Iterator<int>.
typedef typename List<E>::Iterator<E> iterator;

/***    All method declarations and fields for the List class go here.
Any method that returns an iterator must be defined here.
***/
iterator begin() const {  //return an iterator of beginning of list
                          // Call iterator constructor with pointer to List that begin() was 
                          // called with.
    return iterator(this);
}
E back();
E pop_back();
void push_back(const E e);

}; /** end List class declaration **/

Answer 1

The following method definitions are malformed:

E operator* {nodePosition->elem}; //dereference the iterator and return a value
Iterator<E> operator++ {nodePosition = nodePosition->next};  //increment the iterator
Iterator<E> operator-- {
    nodePosition = nodePosition->prev;
}  //decrement the iterator

Even though none of these methods need parameters, the () is still required. The compiler is probably seeing them as variable definitions of some sort and letting things continue long enough to get the error message OP is reporting.

E operator*() {nodePosition->elem}; //dereference the iterator and return a value
Iterator<E> operator++() {nodePosition = nodePosition->next};  //increment the iterator
Iterator<E> operator--() {
    nodePosition = nodePosition->prev;
}  //decrement the iterator

They are also all state that they return a value, but none of the function bodies do. There is a lot more work required here before this code will function.