Question

What I am trying to do, is return a ForwardIterator(or even a pair of begin and end iterators), so that the uderlying implementation can be kept hidden from a client class.
I was not able find any such example.

if underlying implementation is vector, the iterator is vector::iterator.. Even if you templatize the output , this does not seem to work.

Answer 1

You can’t simultaneously return an object as is and expect the caller not to know its type. The typical way to “hide” the real type of any object is to hide it behind an interface.

For example, you might want to write something like this:

template<typename T>
class Cursor
{
public:
    typedef T value_type;
    virtual ~Cursor () {}
    virtual bool has_result () = 0;
    virtual value_type get_result () = 0;
};

// implements cursor interface for any sequence
// described as a pair of forward iterators.
template<typename I>
class ForwardSequenceCursor :
    public Cursor<std::iterator_traits<I>::value_type>
{
    I myCurrent;
    const I myEnd;
public:
     ForwardSequenceCursor(I begin, I end)
         : myCurrent(current), myEnd(end)
     {}
     virtual bool has_result () {
         return myCurrent != myEnd;
     }
     virtual value_type get_result () {
         return *myCurrent++;
     }
};

Then, you can return any forward sequence as:

class Foo
{
    std::vector<int> myValues;
public:
    std::unique_ptr< Cursor<int> > values () {
        return std::unique_ptr< Cursor<int> >(
            new ForwardSequenceCursor<vector<int>::const_iterator>(
                myValues.begin(), myValues.end()
            )
        );
    }
};

And use it like so:

std::unique_ptr< Cursor<int> > cursor = foo.values();
while (cursor->has_result()) {
    std::cout << cursor->get_result() << std::endl;
}