Thread: Function Definitions with Iterators

I've got a specialized container that holds objects of class S. I've got the usual void add(S) and bool remove(S) functions. I'd like to add functions to add and remove a range of elements. For example, something like void add_range(InputIterator<S> begin, InputIterator<S> end) and int remove_range(InputIterator<S> begin, InputIterator<S> end).

I found this link that helped me understand how to define functions that take iterators. However, doing it that way doesn't restrict my range functions to take only InputIterators that have a value_type of S. How can I define a function to take InputIterators with a value_type of S?

Is S a specific thing, or is that your template argument? It's not really clear to me exactly what you're worried about. Can't your specialized container define an iterator type (which the standard containers do, after all) and you use that?

(EDIT: I mean to say, it looks like you're trying to write a function for this specific container, not for any possible container that could ever exist. I don't know, just by looking at the idea of "remove_range", why you care about what S is, when really the important thing would be how the container works.)

S is a specific class, not a template argument.

Here's an example of what I'm trying to do:

Code:

class S 
{ 
   //class definition
};

class special_collection 
{ 
   //class definition
   //only holds objects of class S
   void add_range(InputIterator<S> begin, InputIterator<S> end);
};

void do_stuff()
{
   vector<S> vec;
   special_collection col;
   // add some S's to vec
   col.add_range(vec.begin(), vec.end());
   // do some other stuff
}

While the special_collection will definitely have its own iterator class, it's not useful to define add_range in terms of that iterator class because the iterators can come from anywhere, not just the special_collection. The only restrictions I want to put on the iterator arguments for add_range and remove_range are that they are InputIterators (or at least, not OutputIterators) and have a value_type of S.

While researching in the interim, I kept getting nudges in that direction, but it never really clicked until now. So basically you're saying that I should use InputIterator as if it is an InputIterator with a value_type of S. If someone tries to use something else, the compiler will throw an error eventually.

Since I'm using Boost, it looks like I can throw less ambiguous errors if I use BOOST_MPL_ASSERT to do the type checking.

Thanks for the answer.

Well, basically, you would use it as if it as iterator. So long as you use the standard iterator interface, it will work with any type of iterator, S and otherwise.
Passing in a non-iterator will cause a compile error, naturally. That's the beauty if the static type system.