Can/Should I inherit from an STL iterator?

Question

Can/Should i inherit from STL iterator to implement my own iterator class? If no, why not?

Answer 1

No one should not because of the potential problems that might be encountered. Probably you are better off using Composition rather than Inheritance with STL Iterators.

Undefined Behavior due to absence of virtual destructors:
STL containers & iterators are not meant to act as base classes as they do not have virtual destructors.

For classes with no virtual destructors being used as Base class, the problem arises when deallocating through a pointer to the base class (delete, delete[] etc). Since the classes don't have virtual destructors, they cannot be cleaned up properly and results in Undefined Behavior.

One might argue that there would not be a need to delete the iterator polymorphically & hence nothing wrong to go ahead with deriving from STL iterators, well there might be some other problems like:

Inheritance maynot be possible at all:
All iterator types in the standard container are Implementation defined.
For e.g: std::vector::iterator might be just a T*. In this case, you simply cannot inherit from it.

The C++ standard has no provisions demanding that say std::vector::iterator does not use inheritance inhibiting techniques to prevent derivation. Thus, if you are deriving from a STL iterator you are relying on a feature of your STL that happens to allow derivation. That makes such an implementation non portable.

Buggy behaviors if not implemented properly:
Consider that you are deriving from vector iterator class like:

class yourIterator : std::vector::iterator { ... };

There might be a function which operates on the vector iterators,
For ex:

void doSomething(std::vector::iterator to, std::vector::iterator from);

Since yourIterator is a std::vector::iterator you can call doSomething() on your container class but you will be facing the ugly problem of Object Slicing. The doSomething() has to be implemented in a proper templated manner, to avoid the problem.

Problems while using Standard Library Algorithms:
Consider you are using the derivation from vector iterator, and then you use a Standard library algorithm like std::transform()

For Ex:

yourIterator a;
yourIterator b;
...
std::transform( a++, b--, ... );

The postfix operator ++ returns a std::vector::iterator and not a yourIterator resulting in a wrong template being chosen.

Thus, Inheriting from STL Iterators is possible indeed but if you ready to dig out all such and many other potential problems and address them, Personally I won't give it the time and the effort to do so.