++ operator for a BST Class - c++

Question

I have already created a BST class, with a root node, and left and right node. It is working perfectly. I am trying to create a ++ operator Iterator, which can just go through each node and increment its. This is what I get so far, I am still thinking it gets something to do with my constructor. Below is just the nested Iterator class that I included in the BST class. I just cout to see if it is working but it keeps printing out 0.
class Iterator
{
private:
// private iterator state...
nodeptr root;
public:
Iterator(nodeptr roots_) : root(roots_) {};
~Iterator() {}
bool operator!=(const Iterator& rhs) const { return (this-> root != rhs.root); }
bool operator==(const Iterator& rhs) const {
return (this->root == rhs.root);
}
Iterator operator++(T) {
nodeptr ptr = root;
if (root == NULL)
{
cout << "The tree is empty" << endl;
}
else
{
if (ptr->left != NULL)
{
ptr = ptr->left;
}
cout << ptr->data << " ";
if (ptr->right != NULL)
{
ptr = ptr->right;
}
else
{
cout << "_";
}
}
return *this;
}
}

Answer 1

I don't know what a iterator should do in a BST class, anyway...
(1) I don't know what is a operator++ (T); as far I know, as method of a class, operator++ can be with signature operator++() (pre-increment) or operator++(int) (post-increment); I suppose you're trying to define a post-increment operator (because you add a dummy argument and because you returning a copy of Iterator, not a reference) but the dummy argument should be of type int, not of type T
(2) pre-increment or post-increment, the operator++() should modify the object; your operator doesn't modify it: it create a local copy of the lonely member (root) and modify the local copy; sequential calls to your operator++(T) should give the same effect because are doing the same thing; I suppose your intention was to modify the member root, instead of the local variable ptr
(3) supposing (presence of the dummy argument and no reference in return type) your intention was the make a post-increment operator, you have to create a copy of the object, modify the object and return the copy; you're (not) modifying the object and returning the object itself (return *this;) and this is the typical behavior (adding some change in object and return by reference) of a pre-increment operator.
To make it simple, I suppose you should write something as
// v <--- observe the return by reference
Iterator & operator++ ()
{
// something that modify the Iterator object
// return the object itself as reference
return *this;
}
// no reference here: return a copy
Iterator operator++ (int)
{
// copy of the object **before** the increment
// (but you have also to develop a copy constructor)
Iterator copy { *this };
// pre-increment of the object
++(*this);
// return of the before the increment copy
return copy;
}