Re: throwable .vs. non throwable?
On Jul 24, 3:39 am, "Jim Langston" <tazmas...@rocketmail.com> wrote:
I have a template I use for converting types:
template<typename T, typename F > T StrmConvert( const F from )
{
std::stringstream temp;
temp << from;
T to = T();
temp >> to;
return to;
}
template<typename F> std::string StrmConvert( const F from )
{
return StrmConvert<std::string>( from );
}
As you can see, it doesn't throw.
I don't see that. On my system, it certainly throws in certain
cases. (If you've not exercised this code enough to see a
bad_alloc exception, then you've not tested it enough.)
If the conversion can not take place,
then it simply returns a default constructed type, which is fine for most
cases I use it. However, there may be a case where I want to throw on err=
or.
I know I could simply copy this template and give it a new name, such as
StrmConvertThrow but I don't like that solution. What I would like to be
able to do (which may not be possible) is something like:
int i = 10;
std::string x;
x = StrmConvert( i ):throwable;
or such.
There's no way. Whether a function can throw or not is not
considered in overload resolution, and there's no way for you to
specify that you want a version that doesn't throw, or that
does.
The obvious solution is to make the throwing behavior the
default, and to write something like:
T myT ;
try {
myT = StrmConvert( i ) ;
} catch ( ... ) {
}
in the case where you don't care (which should be extremely rare
in most applications).
I don't think that's right, well, okay, I know it's not right. I
do know that there is a throw( int ) type keyword for functions.
That's an exception specification. The unique example of
programming by contract in the current language---it expresses a
contract, saying that this function will not throw anything
else, and if the function violates the contract, it terminates
the program. (Sort of like assert(), really.)
I tried to duplicate StrmConvert like this:
template<typename T, typename F > T StrmConvert( const F from ) throw(
int )
but got compile time errors.
console5.cpp(17) : warning C4290: C++ exception specification ignored exc=
ept
to indicate a function is not __declspec(nothrow)
console5.cpp(24) : error C2382: 'StrmConvert' : redefinition; different
exception specifications
console5.cpp(3) : see declaration of 'StrmConvert'
so apparently C++ doesn't distinguish between function
signatures by throw or not.
The exception specification is not part of the function
signature. No more than an assert in the body would be.
Although I seem to recall something about there being a new,
and a new throwable.
That's a completely different issue. Normally, new notifies the
lack of memory by throwing std::bad_alloc. If the user wants to
get a null pointer instead, he can use a placement new with a
no_throw additional parameter, and new will return null, rather
than throwing, if there is not enough memory.
Am I barking up the wrong tree, or is there a way to do what I
want?
My immediate reaction would be to avoid this sort of function to
begin with.
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34