Subject: Re: [boost] [lexical_cast] A suggestion
From: Vladimir Batov (batov_at_[hidden])
Date: 2009-02-06 20:24:05
> I have no idea what you mean by dynamic_cast working with "types" not
> "values".
I am sure to do:
Foo& foo = dynamic_cast<Foo&>(moo);
Foo& foo = const_cast<Foo&>(moo);
same instance, different type.
> static_cast<float>(1000000000u) drastically changes the
> representation and the type,
Yes, for static_cast I'll give you that. However, it is not static_cast
*own* quality as it simply piggy-backs on the built-in *language* support
for conversions between *related* types. That way, static_cast is nothing
more but syntactic sugar as "float foo = 10u" will just do.
> just like
> lexical_cast<float>("1000000000") does.
lexical_cast is different as it's not jusr sugar-coating and "float foo =
"10" " wil not take you anywhere. Therefore, if we have to find the closest
?_cast that lexical_cast looks like, then, I'd choose reinterpret_cast --
conversions between *unrelated* types. And I am personally not exactly
comfortable with that comparison as I do not see it serving any useful
purpose.
All in all, these language-supported casts behave *differently* -- the
purpose is the paramaunt. It is arguable if their visual similarity is
beneficial or a hindrance (the user still need to understand their
differences and usage subtleties). Now lexical_cast steps in and seemingly
sactifices usefulness/purpose for appearance. Not the right choice is you
ask me (you obviously are free to disagree).
> And optional<> is not that strange.
To start with "strangeness" is subjective. And that is last of my worries. I
thought I voiced my reasons against it -- it still requires the
default-constructability. I work with quite complex classes which happen not
to have the default constructor. Second, IMHO lexical_cast is seemingly
straightforward (easy to grasp for a casual user). Throwing optional<> into
the mix does not seem justified (that's surely subjective unlike the
default-constructability).
> Or, using the helper:
>
> int i = lexical_cast<optional<int> >(mystring).get_value_or(-1);
>
> Why is this so bad?
Well, if you want lexical_cast (and Boost) *not* used in the wide, then keep
mounting these wonderful complexities and interfaces. Surely the users will
be very supportive of your effort.
Best,
V.