Question

I have to implement a function that takes an iterator. The iterator must dereference to a certain type, say int:

template<typename iter>
  void f(iter i) {
  // do something here ...
  int t = *i;
  // do something here ...
}

The problem with this code is that if a user calls the function like this

vector<string> v;
v.push_back("aaa");
f(v.begin());

he will see an error pointing to some place in my code, not in his code (which will be confusing to him). I want the error to be in user’s code to ease debugging.

Answer 1

GMan already pointed to a method to solve this via compile time assertions. There is another way to do this, which I prefer (it’s my favorite C++ technique). You can put constraints on function arguments in a way that the function is ignored for overload resolution if the constraints don’t fit. This is quite terrific, because you can fine tune your function overloads to arbitrary conditions. Here’s how:

#include <boost/utility.hpp>
#include <boost/type_traits.hpp>
#include <vector>


template<typename Iter> typename
boost::enable_if<
    boost::is_same<typename Iter::value_type,int>,
void>::type
foo(Iter it) { }

int main() {    
    std::vector<int> v; // this is OK
    foo(v.begin());
    std::vector<double> v2; // this is an error
    foo(v2.begin()); }

If you compile this, you will get

b.cc: In function 'int main()':
b.cc:19:16: error: no matching function for call to 'foo(std::vector<double>::iterator)'

This is because the compiler would consider foo() only, if it’s argument has a value_type type inside, which is ‘int’ (This is what the enable_if part means). The second call of foo() can’t satisfy this constraint.

enable_if is mentioned a couple of times in SO, just search for it: https://stackoverflow.com/search?q=enable_if