Question

As far as I can tell in c++ there is no common base class that covers both iterator and reverse_iterator.

The only suggestion I have seen so far is to get around this using templates (
How to write a function that takes an iterator or collection in a generic way? )

However this solution doesn’t seem to work for me.

class MyClass
{
    template<typename Iter> Iter* generate_iterator(...params...)
    {
        //returns either a vector::iterator or vector::reverse_iterator
    }
    template<typename Iter> void do_stuff(Iter *begin, Iter *end)
    {
        //does stuff between elements specified by begin and end
        //I would like this function to remain agnostic of which direction it is working in!
    }
    void caller()
    {
        //I would like this function to remain agnostic of which direction it is working in too...
           do_stuff(generate_iterator(blah),generate_iterator(foo));
    }
};

In this case, generate_iterator() cannot be used as desired because the compiler complains “generate_iterator is not a member of class MyClass” presumably because I haven’t specified it (which I can’t in practice as caller should be agnostic of the iterator type).

Can anyone help? Thanks in advance!

edit: as Mark B pointed out generate_iterator must return a pointer – now corrected

update: just started using this http://thbecker.net/free_software_utilities/type_erasure_for_cpp_iterators/start_page.html and it seems to work…

Answer 1

In C++ you can’t write a function that returns two different types. In your template case it will return one or the other depending on the instantiation. You could possibly return a base pointer to a polymorphic iterator but that would cause me to ask what you’re really trying to do here. Even the standard containers don’t try to do that: They have begin and rbegin to distinguish properly. I would suggest having two separate functions that each do the right thing and return one type of iterator or the other as context dictates.

As a side, note that you can’t implicitly determine a template instantiation of a type that’s only used for the return type of a function.