una - No hay excepción de desbordamiento para int en C#?

que tipos de excepciones existen en c#

Question

Tuve esta extraña experiencia con el problema número 10 en Project Euler (gran sitio por cierto). La tarea era calcular la suma de todos los números primos por debajo de dos millones.

Usé un int para la suma, y ​​mi algoritmo produjo una respuesta, pero cuando pegué para verificar la respuesta, estaba mal.

Resultó que el resultado era demasiado grande para caber en un int, pero ¿no causaría esto un error de desbordamiento o algo así? En cambio, simplemente devolvió un valor muy alejado de la respuesta real.

Cuando cambié el tipo a largo, todo era Hunky Dory.

Answer 1

En C #, no se lanza OverflowException (en VB, la excepción se produce por defecto).

Para obtener la excpetion, debe insertar su código en un contexto checked :

byte value = 241;
checked
{
    try 
    {
        sbyte newValue = (sbyte) value;
        Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.", 
            value.GetType().Name, value, 
            newValue.GetType().Name, newValue);
    }
    catch (OverflowException) 
    {
        Console.WriteLine("Exception: {0} > {1}.", value, SByte.MaxValue);
    }
}       

MSDN explica con más detalle:

Para que la operación aritmética, de conversión o de conversión arroje una OverflowException, la operación debe ocurrir en un contexto verificado. Por defecto, las operaciones aritméticas y los desbordamientos en Visual Basic están marcados; en C #, no lo son. Si la operación ocurre en un contexto no verificado, el resultado se trunca al descartar cualquier bit de orden superior que no se ajuste al tipo de destino.

Answer 2

Es porque, de forma predeterminada, C # no arroja ninguna excepción para el desbordamiento de enteros ni para el subdesbordamiento. Hay un par de cosas que puedes hacer aquí.

Opción 1

Debe habilitar la excepción para que se lance vaya a Proyecto => propiedades => pestaña Construir => Avanzado => comprobar si hay desbordamiento de desbordamiento aritmético. (Asegúrese de marcar la opción)

Asegúrate de marcar la opción

opcion 2

Usa un bloque marcado y lanza una excepción de desbordamiento para manejar la situación. Un fragmento de código de muestra sería

        try
        {
            checked
            {
                int y = 1000000000;
                short x = (short)y;
            }
        }
        catch (OverflowException ex)
        {
            MessageBox.Show("Overflow");
        }
        catch (Exception ex)
        {
            MessageBox.Show("Error");
        }

Espero que esto te ayudará... :)

Answer 3

Por defecto, C # no verifica el desbordamiento aritmético en enteros. Puede cambiar esto con la opción de compilador /checked o habilitando "Comprobar derrame / subdesbordamiento aritmético" en Visual Studio (propiedades del proyecto - Compilación - Avanzado).

Puede usar palabras clave checked y unchecked marcar para anular el valor predeterminado caso por caso. Si confía en que la verificación se realice en un fragmento de código, sería una buena idea habilitarlo explícitamente usando checked .

int j = checked(i * 2);

checked
{
    int j = i * 2;
    // Do more stuff
}

Tenga en cuenta que las operaciones de coma flotante nunca lanzan una OverflowException , y las operaciones decimales siempre arrojan una OverflowException . Ver también msdn .

Answer 4

Ya agregué un cmt, pero tal vez sea interesante para algunos de ustedes:

msdn nos dice:

El desbordamiento aritmético entero arroja una OverflowException o descarta los bits más significativos del resultado

pero

El desbordamiento aritmético decimal siempre arroja una OverflowException.

además

Cuando se produce un desbordamiento de enteros, lo que sucede depende del contexto de ejecución, que se puede marcar o desmarcar. En un contexto verificado, se lanza una OverflowException. En un contexto no verificado, los bits más significativos del resultado se descartan y la ejecución continúa. Por lo tanto, C # le da la opción de manejar o ignorar el desbordamiento.

Answer 5

Las operaciones de enteros C # no arrojan excepciones al desbordamiento por defecto. Puede lograrlo a través de la configuración del proyecto o haciendo que el cálculo se checked :

int result = checked(largeInt + otherLargeInt);

Ahora la operación arrojará.

Lo contrario está unchecked , lo que hace que cualquier operación se desmarque explícitamente. Obviamente, esto solo tiene sentido cuando tienes operaciones comprobadas habilitadas en la configuración del proyecto.