Re: Subtyping iterators

Michael Le Barbier Gr?newald <michipili@googlemail.com> wrote:


  is exploring, so I probably need to supply the corresponding
  (vector.end()) to my cosntructor (so that ++ knows where to stop).
  I feel it is a bit clumsy, is there a nicer way to deal with this?

  In general, operator++ doesn't need to know where to stop because it's
the calling code that compares it to the range end iterator after each
increment.

  (There are some cases where the iterator needs to know more about the
data structure it's handling than just the node it's currently pointing to.
In that case you can store a pointer to the data structure itself in the
iterator. std::back_insert_iterator is a good example of this.)


  want it, since the predicate could also be a member function or
  another callable (and object or a struct with () operator), so I am
  not quite sure about what I should use as a parameter.

  The STL containers and algorithms that support some kind of user-defined
functor (such as a comparison functor) do so by taking the functor type
as template parameter (and then if a member function needs an actual
functor object, it uses that template type to take it as parameter).

  If it's enough for the member function to know what the functor type
is, then you can make that function templated. However, if the entire
class needs to know it (eg. because it stores an object of that type
as a member variable) then there's no other way around it than to make
it a template parameter to the class itself (in which case you have to
specify it when instantiating the class). You can give it some default
value if one is common (in the same way as STL algorithms and data
containers do).

  If you look at the specification of, for example, std::sort() and
std::map, you'll notice that they both take a comparison function as
template parameter (with a default value so that you don't need to
specify it every time if the default suffices).