STL & Generic Programming: Writing Your Own Iterators

Listing 2: The class template iterator_to_member

template<
  typename _It, // type of original iterator
  typename _T,  // type pointed to by original iterator
  typename _R   // type of the member we want to point to
  >
class iterator_to_member
{
  
public:

  // Some typedefs
  //
  typedef typename std::iterator_traits<_It>::iterator_category 
    iterator_category;
  typedef typename std::iterator_traits<_It>::difference_type 
    difference_type;
  typedef _R value_type;
  typedef _R* pointer;
  typedef _R& reference;

  // Construction from an iterator and a pointer to member.
  iterator_to_member(_It from, _R _T::* memptr) : 
    m_it(from), m_memptr(memptr){}

  // Operators *, ->, and [] are first forwarded to the contained
  // iterator, then extract the data member.
  reference operator*() const;
  pointer operator->() const;
  reference operator[](difference_type n) const;

  // All operators that have to do with position are forwarded 
  // to the contained iterator.
  iterator_to_member& operator++();
  iterator_to_member operator++(int);
  iterator_to_member& operator--();
  iterator_to_member operator--(int);
  iterator_to_member& operator+=(difference_type n);
  iterator_to_member operator+(difference_type n) const;
  iterator_to_member& operator-=(difference_type n);
  iterator_to_member operator-(difference_type n) const;

  bool operator==(const iterator_to_member<_It, _T, _R>& rhs) const
  { return m_it == rhs.m_it; }
  bool operator!=(const iterator_to_member<_It, _T, _R>& rhs) const
  { return m_it != rhs.m_it; }

  _It m_it;
  protected:

  value_type _T::* m_memptr;
  
};

template<typename _It, typename _T, typename _R>
inline iterator_to_member<_It, _T, _R>::reference 
iterator_to_member<_It, _T, _R>::operator*() const 
{ return (*m_it).*m_memptr; } 

template<typename _It, typename _T, typename _R>
inline iterator_to_member<_It, _T, _R>::pointer 
iterator_to_member<_It, _T, _R>::operator->() const  
{ return &((*m_it).*m_memptr); } 

template<typename _It, typename _T, typename _R>
inline iterator_to_member<_It, _T, _R>::reference 
iterator_to_member<_It, _T, _R>::operator[](difference_type n) const
{ return m_it[n].*m_memptr; }

template<typename _It, typename _T, typename _R>
inline iterator_to_member<_It, _T, _R>& 
iterator_to_member<_It, _T, _R>::operator++() 
{ ++m_it; return *this; }

// All other operators having to do with position are
// implemented in analogy to operator++().

// Make function for convenient construction.
template<typename _It, typename _T, typename _R>
iterator_to_member<_It, _T, _R> 
make_iterator_to_member(_It it, _R _T::* memptr)
{ return iterator_to_member<_It, _T, _R>(it, memptr); }

— End of Listing —