I've got a really dumb question. My question is illustrated by the
following
code snippit.
template
T inline operator%(const T & lhs, const U & rhs) {
if(0 == rhs)
throw std::domain_error("Divide by zero");
if(boost::is_same::value
&& boost::numeric::is_signed<U>::value
){
if(1 == rhs || -1 == rhs) // is this dropped?
overflow("unsigned type can hold this result");
}
return lhs % rhs;
}
I would like to think that the second if is always
dropped from the compile for a particular pair
of types since this can be evaluated at compile time.
If I'm correct, I can replace some tedious
template metaprogramming for some straightforward
and transparent code inserted in a convenient code
inserted in the most convenient place.
Andre Alex... gave a talk at "Going Native" proposing
a "static if" for this case. But I don't see the necessity for
for this since I would assume that the compiler
just optimises away the "dead" code. I've compiled
the above and it seems to do what I want but
still I wonder.
Basically I see lots of applications of variations
on this idea to get the benefits of tmp without
the attendent pain.
Am I missing anything here?
Robert Ramey
