"Alex Chovanec" <achovane@engin.umich.edu> wrote in message news:cgbhkt$599$1@sea.gmane.org...
Ok, so I have a class Ptr_Wrapper that is a wrapper around a pointer to an object of arbitrary type,
You mean Ptr_Wrapper is not a template? How does it remember the type of object it contains?
and it has a template constructor which accepts any kind of iterator. The constructor initializes the pointer member with the address of the object that the iterator refers to.
Now, I don't want is_convertible<T, Ptr_Wrapper> to be true for any type T, so I want to use the enable_if library to eliminate specializations of the template constructor where the type passed in is not a Readable Lvalue iterator with the correct pointer type. But again, I can't just use is_readable_iterator<T> and is_lvalue_iterator<T>, because either one will cause a compile error if T is not an iterator.
I don't want there to be a compile error in this case, because Ptr_Wrapper has another constructor which accepts a reference to an object an initializes the pointer member from that.
I want this constructor to be chosen if a reference is passed instead of an iterator.
Thus, in the template metaprogram that I use to decide whether or not to include a particular template specialization of the constructor in
Possibly dumb question: why not have this second overload take a pointer? the set
of candidate functions, I need to check that T is some kind of iterator before applying is_readable_iterator<T> and is_lvalue_iterator<T>. Otherwise, I may get an unwanted compile error.
Okay, assuming the second overload has to take a reference, this does sound like a case where you want to be able to treat almost any possible type. Realistically, how often would: template<typename T> Ptr_Wrapper( const T&, typename enable_if< is_incrementable<T> >::type* = 0, typename enable_if< is_dereferenceable<T> >::type* = 0 ); template<typename T> Ptr_Wrapper( T&, typename disable_if< is_incrementable<T> >::type* = 0, typename disable_if< is_dereferenceable<T>
::type* = 0 );
select the wrong overload? If it's fairly rare, you could add a disambiguation mechanism: Ptr_Wrapper pw = Ptr_Wrapper::from_object(x); or Ptr_Wrapper pw( disambiguation_func_with_better_name(x) ); Jonathan