Subject: Re: [boost] [Conversion] Practical applications
From: Phil Endecott (spam_from_boost_dev_at_[hidden])
Date: 2011-08-23 13:05:03
Hi Vicente,
Vicente J. Botet Escriba wrote:
> Le 22/08/11 22:50, Phil Endecott a ?crit :
>> Vicente J. Botet Escriba wrote:
>>> If we can construct implicitly a pair from another pair of implicitly
>>> convertible types, why we couldn't allow the conversion from a pair
>>> of type that are extrinsically implicitly convertible to them?
>> Right. But does your library make this possible?
> The specialization of the customization point implicit_convert_cp allows
> to convert 'implicitly' pairs of extrinsicaly convertible types using
> the implicit_convert_to function. Now the user ca use the
> explicit_convert_to function to convert these types as for example
>
> B1 b1;
> B2 b2;
> std::pair<B1,B2> b;
> std::pair<A1,A2> a1(boost::conversion::explicit_convert_to<std::pair<A1,A2> >(b));
>
> Note that implicit convertible implies explicit convertible.
>
> I wrote implicitly with coutes because we need to use a function which
> makes the call explicit.
> Resuming, the user wanting extrinsically implicit conversions, must use
> explicitly the 'implicitly' function.
I was really hoping that I had misunderstood something and that
actually your library could make it possible to have extrinsic implicit
conversions. But it doesn't; the conversions still require additional
syntax. So they aren't implicit conversions.
Since you can't add this additional syntax to e.g. the std::
algorithms, I am still struggling to see how the library is useful.
> Imagine that library A defines
>
> struct T {
> int i;
> int j;
> };
>
> and library B defines
>
> struct R {
> long x;
> long y;
> };
>
> I magine now that you recover an array<T,3> from library A and that you
> need to use some functions in library B that need a c-array R[3].
>
> If you stablish a conversion from T to R using convert_to and if you
> have that an array<T,N> can be assigned to an R[N] you could do the
> following
>
> array<T,3> source;
> // call some functions in A that fill this array
>
> A_f(source);
>
> //Now you need to present this data to the B library
> R target[3];
>
> // convert source to target
> assign_to(target,source);
>
> // uses target in a B function
>
> B_g(target);
Or you could just:
array<T,3> source;
A_f(source);
R target[3];
std::transform(source.begin(),source.end(),target,&R_to_T);
B_g(target);
where R_to_T is the same conversion function that you need - but with
the advantage that I can define multiple conversions between each pair
of types, if I want to.
Regards, Phil.