Re: test if a string is a valid 'number'?
On Thu, 31 May 2007 07:24:13 GMT, MrAsm <mrasm@usa.com> wrote:
I don't agree.
It's easier and more elegant (IMHO) to use a single catch (
bad_lexical_cast & ) than process all the possible error codes of
strtod (and similar functions):
<strtod return value>
The strtod() function returns the converted value, if there is any. If
no conversion could be performed, strtod() returns zero. If the
correct value is outside the range of representable values (plus or
minus), strtod() returns HUGE_VAL (according to the sign of the value)
and sets errno to ERANGE. If the correct value causes underflow,
strtod() returns zero and sets errno to ERANGE.
</strtod return value>
vs.
just a catch( bad_lexical_cast & ).
And I see no problem in locally catching the exception and not
propagate it upwards the call chain.
This is the code sample from Boost lexical cast page:
<CODE url="http://www.boost.org/libs/conversion/lexical_cast.htm">
int main(int argc, char * argv[])
{
using boost::lexical_cast;
using boost::bad_lexical_cast;
std::vector<short> args;
while(*++argv)
{
try
{
args.push_back(lexical_cast<short>(*argv));
}
catch(bad_lexical_cast &)
{
args.push_back(0);
}
}
...
}
</CODE>
They are just doing the catch locally, as I intended.
I think it's better than doing several if for strtod error conditions.
I would bet that lexical_cast can fail for all the reasons strtod can fail,
so catching bad_lexical_cast is equivalent to using a strtod wrapper that
returns bool such as the StrToDouble function I presented in one of those
messages I linked to, or using another variant on the multiple return value
theme such as a bool result parameter. Don't mistake the Boost example for
good practice; examples demonstrate how to use something, and they often
ignore other considerations. (For example, how many examples have you seen
that ignore error checking?) This example is silly, and it would be even
sillier had short been replaced by int, because then they could've replaced
the whole shebang with atoi; I'd say they'd have been better off writing an
"atos" function in terms of strtol that behaves like atoi, because that
would have allowed them to write:
while(*++argv)
args.push_back(atos(*argv));
They'd also be able to use atos wherever they contemplated using the
try/catch crap. But think about it: How often in real life do you silently
replace invalid input with zero? Not very often, so this example
demonstrates my point rather nicely. It's mostly nonsense, but it clearly
shows how to use the thing, so in that respect, it's a good example.
Here's a good rule of thumb: The number of try/catch blocks you have is
inversely proportional to the degree to which you are using exceptions
effectively. Code such as the above example uses exceptions as expensive,
clumsy return codes. It's not what you want to do on a regular basis.
Looking at lexical_cast, I'm reminded of dynamic_cast, and the vast
majority of the time, I use the pointer form of dynamic_cast rather than
the reference form which throws bad_cast. The pointer form, i.e. the
"return code" form, is just a lot more convenient. Unfortunately,
lexical_cast has to make do with throwing exceptions.
--
Doug Harrison
Visual C++ MVP