Re: Unsigned types are DANGEROUS??

From:

"MikeP" <mp011011@some.org>

Newsgroups:

comp.lang.c++

Date:

Thu, 17 Mar 2011 13:29:22 -0500

Message-ID:

<iltjto$op9$1@speranza.aioe.org>

Leigh Johnston wrote:

int exception_filter(unsigned int code)
{
if (code == EXCEPTION_INT_OVERFLOW)
return EXCEPTION_EXECUTE_HANDLER;
else
return EXCEPTION_CONTINUE_SEARCH;
}

int main()
{
__try
{
int n = INT_MAX;
++n;
_asm INTO
}
__except(exception_filter(GetExceptionCode()))
{
std::cout << "hmm";
}
}

But doing the above is obviously non-portable and totally
non-standard in addition to being utter garbage IMO; the C++
language makes no gaurantees about what CPU flags are set and when
so you would have to double check the assembler output of the
compiler to ensure the overflow flag is set or unset before the INTO
instruction and even then you wouldn't catch such mistakes as:

int n = INT_MAX;
int n2 = ((n + 1) * 2);
_asm INTO

as the multiplication is the last operation to affect the overflow
flag so the overflowing sub-expression escapes.

Or as actually happens on my implementation the entire expression is
optimized to an instruction which does not affect the overflow flag
at all.
So basically VC++ (VS2008) does not support detection of signed
integer overflow; using in-line assembler doesn't does not equate to
"support" IMO.

Well that settles that then. So who is going to write up the proposal to
the committee for a new integer type(s)?