Why do we allow overflow by default?

Question

I had a theory that casting from long to int with a value greater than int.MaxValue or less than int.MinValue would result in an exception. The issue I had at the time was identifying which type of exception was going to be thrown. I naturally assumed it would be an OverflowException or an InvalidCastException, but imagine my surprise when the following snippet didn't explode at all!

int x = 0;
long y = int.MaxValue;
y += 3;

try {
    x = (int)y;
} catch (Exception e) {
    Console.WriteLine(e.GetType());
}

This instead resulted in a value equal to int.MinValue + 2:

x:            -2147483646
int.MinValue: -2147483648

So my curiosity has the best of me at this point, and I've done a fair amount of digging to learn that I can cause an exception to be thrown (thanks to this post) by utilizing the checked keyword (emphasis mine):

Overflow checking can be enabled by compiler options, environment configuration, or use of the checked keyword. The following examples ... Both examples raise an overflow exception.

Meaning, if I simply utilize the checked keyword, an OverflowException will be thrown (and it is):

try {
    x = checked((int)y);
} catch (Exception e) {
    Console.WriteLine(e.GetType());
}

After reading this article on MSDN, I've learned that the default behavior is to allow the overflow to occur:

By default, these non-constant expressions are not checked for overflow at run time either, and they do not raise overflow exceptions. The previous example displays -2,147,483,639 as the sum of two positive integers.

TL/DR: Why is the default behavior in C# to allow overflow to occur? Doesn't this lead to unexpected behaviors?

Note: I understand that the bit flips and that's what causes it to go negative; I'm just curious as to why it's allowed to flip instead of throwing an exception by default. In a nutshell, why do we have to explicitly state we want things to explode?

I think it's wrong to think of a "bit flip" that makes the result negative. Instead, the byte representation of a `long` is truncated to the number of bytes for an `int`. — Code-Apprentice, Oct 29 '20 at 17:53
@jdweng I'm not sure I follow. `int` is a 32 bit integer and `long` is 64 bits? Where did you get `Int16` from? — Hazel へいぜる, Oct 29 '20 at 17:57
performance, the reason is... just like arrays don't start with 1 — Patrick Beynio, Oct 29 '20 at 17:57
Questions of the ilk "what was Microsoft thinking when.." are usually off topic — Caius Jard, Oct 29 '20 at 18:02
@jdweng: serious? - I thought 2^16 was something like 65536 ;-) — Stefan, Oct 29 '20 at 18:02
@jdweng I know this question is closed at this point, but as an FYI (per Google, not me): `short: 16 bits [-32768 to 32767]`. — Hazel へいぜる, Oct 29 '20 at 18:05
To get an overflow on a negative number you have to subtract and you are adding. — jdweng, Oct 29 '20 at 18:05
@jdweng I understand that, it sounded like you were stating that a 16 bit number is orders of magnitude larger than it really is. — Hazel へいぜる, Oct 29 '20 at 18:06

Why do we allow overflow by default?

0 Answers0