Question

class X {
  public:
    typedef std::list<int> Container;

    // (1)
    const Container& GetElements() const;

    // (2)
    Container::iterator ElementBegin();
    Container::iterator ElementEnd();

    // (3)
    CustomIterator GetElementIterator();

  private:
    Container m_container;
};

I’m looking for a consistent and clean way of providing iterators to encapsulated containers to the caller. I came up with the three ideas marked in the source code above.

1. Provides size(), begin() and end(), all perfect for read access. However, because the returned Container reference is const, you’ll only be able to use const_iterator. Returning the reference non-const is bad, because the container itself could be modified (e.g. clear()).
2. Provides non-const access to the elements, however we’d often need an own size() method (like GetElementCount()). iterator::distance() could be used, but that may be inefficient for some containers (where operator++/-- is called repeatedly to calculate the distance).
3. Provides a custom iterator with methods like next() etc. Still an own size() method is required.

I highly bet there’re nicer solutions, so if you know any, I’d be glad to see them.

Answer 1

A mix of (2) and (3) would probably be what I’d do :

class X {
  public :
    typedef std::list<int> ElementContainer;
    typedef ElementContainer::size_type ElementSizeType;
    typedef ElementContainer::iterator ElementIterator;
    typedef ElementContainer::const_iterator ConstElementIterator;

    ElementIterator elementBegin() { return m_container.begin(); }
    ElementIterator elementEnd() { return m_container.end(); }

    ConstElementIterator elementBegin() const { return m_container.begin(); }
    ConstElementIterator elementEnd() const { return m_container.end(); }

    ElementSizeType elementSize() const { return m_container.size(); }

  private :
    ElementContainer m_container;
};

It still leaves room to write custom iterators (by changing the typedefs), but as long as the ones provided by the container are ok, they can be used.