INSTITUTO TECNOLÓGICO DE SANTO DOMINGO

ÁREA:
Área de Ingenierías

ASIGNATURA:
Programación II (INS214)

DOCENTE:
Lorenzo Solano Martínez

ASIGNACIÓN SOBRE:
Investigación grupal

SECCIÓN:
01

SUSTENTANTES Y MATRÍCULAS:
Alexander Meléndez Santiago ICS-1088455
Ariana Isabella López Ward IDS-1092967
Ian Rafael De los Santos Pouerie IDS-1095250
José Carlos Contreras Romero IDS-1095948
Elvis Rafael Cambero González IDS-1088410

4 de Septiembre del 2020

Santo Domingo, D.N.
República Dominicana
Grupo 6

Errores Underflow y Overflow

Al hablar de los tipos de errores que ocurren en C# y Java al incrementar o disminuir variables numéricas
más allá de su límite superior o inferior, respectivamente, nos referimos a los overflow y underflow que
suceden al asignar un valor fuera del rango del tipo de data declarado en la variable. Si el valor absoluto
es demasiado grande, le llamamos overflow, si es demasiado pequeño, le llamamos underflow. Veremos
un ejemplo de lo que pasa al intentar asignarle un valor de 101000 (1 con 1000 ceros) a una variable de
tipo int, de igual forma, intentaremos asignarle un valor de 10−1000 a una variable de tipo double, ambos
ejemplos comprobados en el lenguaje de programación de Java.

En Java, un integer de tipo int puede ser negativo o positivo, lo que significa que con sus 32bits podemos
Asignarle valores entre −231 y 231 . La wrapper class o clase contenedora en español, define dos
constantes que contiene los valores Integer.MIN_VALUE y Integer.MAX_VALUE. Normalmente, al
intentar definir una variable de tipo int asignándole un valor = MAX_VALUE + 1, el resultado sería una
variable indefinida o que se presente un error. Pero en el caso de Java, el valor sería -2147483648 (el valor
mínimo), y si se intenta utilizar MIN_VALUE – 1, el resultado sería 2147483647 (el valor máximo). Este
comportamiento se conoce como integer-wraparound. Ejemplo:
OUTPUT:
1 2147483646
2 2147483647
3 -2147483648
4 -2147483647

int value = Integer.MAX_VALUE-1;a

for(int i = 0; i < 4; i++, value++) {a
System.out.println(value);a
}a

En el caso de C#, al tener una operación aritmética que produce un resultado fuera del rango del tipo de
data retornado por la operación se produce un error llamado OverflowException. El OverFlow Exception
ocurre bajo ciertas condiciones donde: a) una operación aritmética genera un resultado que está fuera del
intervalo del tipo de datos devuelto por la operación o b) una operación de conversión o conversión intenta
realizar una conversión de restricción y el valor del tipo de datos de origen está fuera del intervalo del tipo
de datos de destino. Sin embargo, este error solo se produce cuando la operación se realiza en un contexto
comprobado. Si la operación se produce en un contexto no comprobado, el resultado se trunca descartando
los bits de orden superior que no caben en el tipo de destino.
Aquí un ejemplo de un try-catch que produce este error:

int value = 780000000;

checked {
try {
// Square the original value.
int square = value * value;
Console.WriteLine("{0} ^ 2 = {1}", value, square);
}
catch (OverflowException) {
double square = Math.Pow(value, 2);
Console.WriteLine("Exception: {0} > {1:E}.",
square, Int32.MaxValue);
} }
// The example displays the following output:
// Exception: 6.084E+17 > 2.147484E+009.

Ejemplo en C# en un contexto no comprobado:

byte value = 241;
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);
}
// The example displays the following output:
// Converted the Byte value 241 to the SByte value -15.
Soluciones

• Java
Un detalle importante sobre los errores underflow y overflow en Java es que NO lo van a
reportar sólo lo “absorberán”, como se sugirió posteriormente.
Esto en sí ya es peligroso, el programador no tiene forma de saber que ha cometido un error,
continuará codificando y puede ocasionar problemas en el futuro.

A continuación, se muestran las tres técnicas principales para detectar los errores de underflow y
overflow de enteros no intencionado:

a) Prueba de condiciones previas: revise las entradas de cada operador aritmético para
comprobar si hay errores y, ponga un ArithmeticException en el caso de que produzca
algún error. Tenga en cuenta que esta manera puede ser compleja y consumir mucho
tiempo.

b) Upcasting/Downcasting: Convierta la entrada al siguiente o anterior tipo de dato

primitivo que le sigue y vuelva a realizar la operación. Verifique cada resultado para ver
si hay overflow/undeflow del tipo más original y arroje una ArithmeticException si falla
la verificación de rango. Recuerde que la revisión de rango debe realizarse después de
cada operación, porque las expresiones más grandes sin comprobación de límites por
operación pueden dar overflow al tipo más grande. Este método no funciona con los tipos
long y byte, ya que es el tipo más grande y pequeño respectivamente.

c) BigInteger: Convierta las entradas en objetos de tipo BigInteger y realice toda la

aritmética utilizando métodos BigInteger. BigInteger es el tipo de entero de precisión
arbitraria estándar proporcionado por las bibliotecas estándar de Java. Las operaciones
aritméticas implementadas como métodos de este tipo no pueden desbordarse; en cambio,
producen el resultado numéricamente correcto. En consecuencia, el código compatible
realiza una única verificación de rango justo antes de convertir el resultado final al tipo
más pequeño original y arroja una ArithmeticException si el resultado final está fuera del
rango del tipo más pequeño original. Esta es la manera más sencilla de prevenir los
errores ya mencionados, pero no es perfecto.
• C#
En C# para lograr que las operaciones con números enteros no lancen excepciones al
desbordamiento por defecto.
Podemos lograr esto cambiando la configuración del proyecto, o haciendo que el cálculo de la
checked.

Cambiando la configuración del proyecto:

Para evitar este problema, convierta el tipo de datos numérico al tipo de datos Double o al tipo de
datos Int64. Para ello, siga estos pasos:
1. Haga doble clic en el grupo en el panel Grupos de fila o Columna para abrir las propiedades
del grupo.
2. En la ficha General, cambie la expresión de grupo en la siguiente expresión de tipo de datos
de System.Double:
CDbl(Fields! < nombre de campo >. Valor)
O bien, cambiar la expresión de grupo a los siguientes tipos de System.Int64:
CLng(Fields! < nombre de campo >. Valor).

Mediante el cálculo de la checked:

int result = checked(largeInt + otherLargeInt);

Ahora la operación de tiro.

El opuesto es unchecked, lo que hace que cualquier operación de forma explícita

desactivada. Obviamente, esto sólo tiene sentido cuando tienes las operaciones verificadas
habilitado en la configuración del proyecto.
Referencias bibliográficas

● OverflowException Clase (System). (2020). Retrieved 4 September 2020, from

https://docs.microsoft.com/es-mx/dotnet/api/system.overflowexception?view=netcore-3.1

● System.OverflowException Class. (2020). Retrieved 4 September 2020, from

https://www.gnu.org/software/dotgnu/pnetlib-doc/System/OverflowException.html

● Mertikas, E., & Snavely, W. (2018, 12 febrero). NUM00-J. Detect or prevent integer overflow -
SEI CERT Oracle Coding Standard for Java - Confluence. SEI External Wiki.
https://wiki.sei.cmu.edu/confluence/display/java/NUM00-
J.+Detect+or+prevent+integer+overflow

● Anonimo. (2018, Septiembre 20). Microsoft. Retrieved from https://support.microsoft.com/es-

do/help/2359606/fix-system-overflowexception-value-was-either-too-large-or-too-small-f

● Rudolph,K.(13 de Enero de 2010). Iteramos. Obtenido de

https://www.iteramos.com/pregunta/60020/no-hay-excepcion-de-desbordamiento-de-int-en-c