Re: [Boost-users] Using boost::enable_if with template copy constructors

From: Tim Robertson (timr_at_[hidden])
Date: 2006-09-06 16:13:39

On Sep 6, 2006, at 12:19 AM, David Abrahams wrote:

> But that's probably not what you meant for it to do.  In this case
> it looks like you have a kind of circular dependency problem.  You can
> actually learn a lot by reading the error messages. Reversing your
> instantiation backtrace, I get:
>
>> test.cpp:36:   instantiated from here
>
> I assume that's the 2nd line of main()

>> test.cpp:36:   instantiated from 
>> `boost::enable_if<boost::is_convertible<Foo, Foo>, void>'
>
> It's trying to decide if the first ctor is a match
>
>> test.cpp:36:   instantiated from `boost::is_convertible<Foo, Foo>'

Yes, everything up to this point was straightforward.  The compiler is 
trying to choose between the constructors by instantiating the various 
enable_if templates.   Unfortunately, I'm not as familiar with the 
internals of enable_if<> as many of you, and the *next* part was a bit 
confusing...

>
> To do that it needs to decide the value nested in 
> is_convertible<Foo,Foo>.
>
>> test.cpp:36:   instantiated from 
>> `boost::detail::is_convertible_impl_dispatch<Foo, Foo>'
>> /boost/boost/type_traits/is_convertible.hpp:228:   instantiated from 
>> `boost::detail::is_convertible_impl<Foo, Foo>'
>> /boost/boost/type_traits/is_convertible.hpp:128:   instantiated from 
>> `boost::detail::is_convertible_basic_impl<Foo&, Foo>'
>
> Inside implementation details of is_convertible:
>
>> /boost/boost/type_traits/is_convertible.hpp: In instantiation of 
>> `boost::disable_if<boost::is_convertible<Foo, Foo>, void>':
>
> To determine convertibility it has to check out the ctors and see if
> there's one that implicitly converts Foo->Foo

...but it can't do that if the constructors that would perform the 
conversion are themselves enabled/disabled with enable_if?

>> /boost/boost/type_traits/is_convertible.hpp:128: error: `value' is 
>> not a member of type `boost::is_convertible<Foo, Foo>'
>
> In evaluating the applicability of the first ctor, it needs to know
> the value nested in is_convertible<Foo,Foo>.  We've been here before!
>

Right.  So again, it seems as though it isn't possible to do what I'm 
trying to do.  The enable_if<> template requires the use of the class' 
copy constructor.  Even if a default copy constructor is provided, the 
compiler still wants to obtain the nested value type in 
is_convertible<>, and it can't do that, because it needs to decide 
between the three copy-constructor-like functions in the class, two of 
which depend on enable_if<> to determine their signatures.  Is that the 
correct way to interpret this situation?

In retrospect, this was probably too trivial an example to give you -- 
I realize that it's silly to want to use enable_if<> to do what the 
compiler can do for itself.  There's a far more complex situation 
behind the question, but I'm having trouble distilling it down to a 
question of reasonable length....

-Tim