Dividir por cero con VisualBasic seguro que no adivinas el resultado

| | Comentarios (1) | TrackBacks (1)

Cuando salió Visual Basic .NET muchos se quejaron de que ya no era Visual Basic, que era otra cosa... parecida pero otra cosa. Yo desde mi modesta posición, quiero desde aquí confirmar de que Visual Basic .NET realmente sigue siendo Visual Basic. Para eso os remito al siguiente ejemplo.

Tomemos dos pequeños programas, uno escrito en Visual Basic .NET y el otro en Csharp. Y probemos el resultado con un compilador y con el otro.

    Try
            Dim a As Integer = 1
            Dim b As Integer = 0
            Dim c As Double = a / b
            MessageBox.Show(c.ToString)
    Catch ex As DivideByZeroException
            MessageBox.Show("DivideByZeroException")
    Catch ex As Exception
            MessageBox.Show("Exception")
    End Try

Y por otro lado:

    try
    {
            int a = 0, b = 0;
            decimal c = a / b;
            MessageBox.Show(c.ToString());
    }
    catch (DivideByZeroException)
    {
            MessageBox.Show("DivideByZeroException");
    }
    catch (Exception)
    {
            MessageBox.Show("Exception");
    }

Como se suele decir, cuando se divide algo entre 0 debería aparecer una excepción de DivideByZero... por lo menos así me lo enseñaron a mi, y así ocurre con csharp. Pero no. En Visual Basic obtenemos otro valor... (que siendo sinceros no está mal)... obtenemos: "Infinito".

Ahora la explicación:

Yo divido dos enteros entre si, y obtengo un Double, para eso estoy (o debería) usar el operador divide que tiene implementado el tipo Integer y obtener un Double. Por definición de este tipo/operador cuando se divide algo por Cero se obtiene la excepción DivideByZeroException.

Si en vez de int/integer hubiese usado Double para guardar los números habría obtenido tanto en Visual Basic como en Csharp "Infinito". Y es que aquí viene lo curioso, el tipo Double además de números finitos puede guardar otros números:

  • Positive and negative zero.
  • Positive and negative infinity.
  • Not-a-Number value (NaN).
  • The finite set of nonzero values.

Por lo que si se dividen dos doubles en .NET se puede obtener de resultado un infinito. El problema es que Visual Basic cuando ve nuestra división él por su cuenta y riesgo convierte los Integers en Doubles, y claro con Doubles si que se puede obtener el resultado de Infinito y por eso no aparece ninguna excepción por ningún lado.

Y es lo que digo yo, y por mucho que traten de convencernos, cuando se programa con Visual Basic el compilador asume que el programador no tiene ni idea y el compilador intenta "arreglar" el código; por desgracia la suele cagar. Por eso digo que VB .NET sigue siendo VB... a estas alturas sigue siendo un lenguaje para principiantes por mucho que nos pese o nos intenten decir lo contrario.

Bueno, en el fondo creo que no queda claro, pero, otro día ya escribiré sobre otras lineas de código curiosas de nuestro amiguito.

Categorías

1 TrackBacks

Abajo están listados los blogs que hacen referencia a esta entrada: Dividir por cero con VisualBasic seguro que no adivinas el resultado.

URL de TrackBack de esta entrada: http://www.victor.eu.org/cgi-bin/mt/pings/70

A veces veo cosas sin sentido en los doubles de... Leer más

1 Commentarios

Antonio dijo:

Pero eso ocurre porque has usado tipos de datos distintos: Double en vb.net y decimal en C#. Prueba con Decimal el vb.net y double en C#.

Escribir un comentario

Sobre esta entrada

Esta página contiene una sola entrada realizada por Víctor y publicada el 21 de Diciembre 2006 1:06 AM.

Preguntas sin respuesta es la entrada anterior en este blog.

La página que está abriendo contiene tanto elementos seguros como no seguros es la entrada siguiente en este blog.

Encontrará los contenidos recientes en la página principal. Consulte los archivos para ver todos los contenidos.

Publicidad