operator++(int) overload with abstract base class and Wall - c++

Question

I am currently creating a set of iterators which will differ in implementation detail, but will be used in the same algorithms. For this reason, they must all have the same interface. To achieve this, I created an abstract iterator class and inherited from this class in all further iterators.
This should give you an idea of what my code looks like:
class INodeIterator
{
public:
virtual ~INodeIterator() {};
virtual bool operator!= (const INodeIterator& other) =0;
virtual bool operator== (const INodeIterator& other) =0;
virtual INodeIterator& operator++ () =0;
virtual INodeIterator& operator++ (int i) =0;
virtual Node& operator* () =0;
};
class NodeIterator : public INodeIterator
{
public:
/* snip */
NodeIterator& operator++ (int i)
{
NodeIterator tmp(*this);
++(*this);
return(tmp);
}
};
Now I am facing the same problem as in C++ post-increment operator overload in iterators (compiling with -Wall -Werror): My operator++(int) implementation throws a warning (gcc 4.8.0) that a reference to a temporary is returned. The solution in the linked question was to just return the object instead of the reference.
However, this will not work for me. If I change both interface and derived class to return an object instead of a reference, the following errors appear (excerpt, additional file names etc. removed):
INodeIterator.h:16:27: error: invalid abstract return type for member function ‘virtual INodeIterator INodeIterator::operator++(int)’
virtual INodeIterator operator++ (int i) =0;
^
NodeIterator.h:33:22: error: invalid covariant return type for ‘virtual NodeIterator NodeIterator::operator++(int)’
NodeIterator operator++ (int i);
^
INodeIterator.h:16:27: error: overriding ‘virtual INodeIterator INodeIterator::operator++(int)’
virtual INodeIterator operator++ (int i) =0;
^
Changing the return type to object on the derived class but not on the abstract class expectedly returns a "conflicting return type specified" error.
How can I make this work?

Answer 1

Try to change design: let's NodeIterator holds INodeIterator as a pointer. All methods of NoteIterator will delegates to the holding INodeIterator object. In that case you can use correct signature:
struct IteratorInterface {
virtual ~IteratorInterface() {}
virtual std::unique_ptr<IteratorInterface> clone() const = 0;
virtual void next() = 0;
};
class Iterator {
std::unique_ptr<IteratorInterface> impl;
public:
Iterator(std::unique_ptr<IteratorInterface> r) : impl(std::move(r)) {}
Iterator(const Iterator &r) : impl(r.impl->clone()) {}
Iterator& operator++() {
impl->next();
return *this;
}
Iterator operator++(int ) {
Iterator tmp(*this);
impl->next();
return tmp;
}
void swap(Iterator &other) {
other.impl.swap(impl);
}
};
int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
struct IteratorInterfaceImpl : IteratorInterface {
int i;
IteratorInterfaceImpl() : i(0) {}
virtual std::unique_ptr<IteratorInterface> clone() const {
return std::unique_ptr<IteratorInterface>(new IteratorInterfaceImpl(*this));
}
virtual void next() {
i += 1;
}
};
Iterator tmp(std::unique_ptr<IteratorInterface>(new IteratorInterfaceImpl()));
tmp++;
++tmp;
return 0;
}

Answer 2

The only sane way I can think of is to return void from INodeIterator::operator++(int) - i.e. nothing.
You can't return a reference from the post-increment operator, because you'll have to create an actual object (storing the previous value) of which you return a reference. This object is either dynamically allocated and would have to be destroyed (had to call delete explicitly on the reference returned) or it is a "local variable" of operator++(int) and will get destroyed before returning:
virtual NodeIterator& operator++(int)
{
NodeIterator prev_value(*this);
++(*this);
return prev_value; // dangling/invalid reference, `prev_value` is destroyed
}
virtual NodeIterator& operator++(int)
{
NodeIterator* pPrev_value = new NodeIterator(*this);
++(*this);
return *pPrev_value; // have to explicitly call delete on the returned ref...
}
You also cannot return an object of type INodeIterator from INodeIterator::operator++(int) because it's an abstract class.

Answer 3

The reason you get the error
INodeIterator.h:16:27: error: invalid abstract return type for member function ‘virtual INodeIterator INodeIterator::operator++(int)’
virtual INodeIterator operator++ (int i) =0;
Is because your pure virtual function returns a abstract class object.
One solution is to use new operator and return the object created in heap, which is safe.
virtual INodeIterator& operator++ (int i) =0;
NodeIterator& operator++ (int i)
{
NodeIterator* tmp = new NodeIterator (*this);
++(*this);
return(*tmp);
}

Answer 4

Your prototype is incorrect. It should be
NodeIterator operator++ (int i)
That is, drop the reference return, otherwise you are returning a reference to something that has gone out of scope (your tmp) Not a good idea!
And the compiler was being very helpful in letting you know this!
Not quite what you wanted to hear I know.