Los límites de la variable doble en c ++

las variables de punto flotante en C ++ vienen con sus propias limitaciones. No se pueden utilizar para contar las cosas, que tardan más en proceso, que consumen más memoria, y ellos también sufren de errores de redondeo (aunque no es tan malo como int). Ahora para considerar cada uno de estos problemas en turno.

Contando con el doble

No se puede utilizar una variable de punto flotante en una aplicación donde el conteo es importante. En C ++, no se puede decir que hay 7,0 personajes de mi nombre de pila. Operadores involucrados en el conteo no funcionan en las variables de punto flotante. En particular, el incremento automático (++) y auto-decremento (- -) Los operadores son estrictamente verboten en doble.

Video: float y double en C++ [Curso de Programación C++] [7/28]

velocidad de cálculo de la doble

Las computadoras pueden realizar aritmética de enteros rápido de lo que pueden hacer aritmética de punto flotante. Afortunadamente, los procesadores de punto flotante se han integrado en las CPUs desde hace muchos años, por lo que la diferencia en el rendimiento no es tan importante como lo era antes. El siguiente bucle fue escrito sólo como un ejemplo simple, primero utilizando la aritmética de enteros:

int nValue1 = 1, nValue2 = 2, nValue3 = 2-for (int i = 0- i lt; 1000000000- i ++) {int nAverage = (nValue1 + nValue2 + nValue3) / 3-}

Este bucle llevó unos 5 segundos en ejecutarse. Ejecutar el mismo bucle en aritmética de punto flotante:

doble dValue1 = 1, dValue2 = 2, dValue3 = 2-for (int i = 0- i lt; 1000000000- i ++) {double BDPROMEDIO = (dValue1 + dValue2 + dValue3) / 3.0-}

Esta mirada tomó alrededor de 21 segundos en ejecutarse. Calculando un promedio de 1 mil millones de veces en un poco más de 20 segundos no está en mal estado, pero aún así es cuatro veces más lento que el tiempo de procesamiento para su equivalente entero.

La variable doble consume más memoria

En un PC o Macintosh, una int consume 4 bytes, mientras que una doble ocupa 8 bytes. Eso no suena como mucho - y, de hecho, no lo es - pero si tienes unos cuantos millones de estas cosas para mantener en la memoria. . . así, todavía no sería mucho. Pero si tuviera unos cuantos cien millones de dólares, entonces la diferencia sería considerable.

Video: La Variable Double en C/C++ [Curso de Turbo C] [9/42]

Esta es otra forma de decir que a menos que necesite almacenar una diablos de un montón de objetos, no se preocupe por la diferencia en la memoria tomada por un tipo u otro. En su lugar, elegir el tipo de variable que se adapte a sus necesidades.

Si acaba de pasar a ser la programación de una aplicación que necesita (por ejemplo) para manipular la edad de cada ser humano en el planeta al mismo tiempo, entonces es posible que desee a inclinarse hacia los más pequeños int ya que consume menos memoria. (¿Lo haces ese tipo de cosas a menudo?)

La pérdida de precisión con doble

Una variable doble tiene cerca de 16 dígitos significativos de precisión. Tengamos en cuenta que un matemático expresaría el número 1/3 como 0,333. . ., Donde los puntos suspensivos indican que los tres en tres para siempre. El concepto de una serie infinita tiene sentido en matemáticas, pero no en la computación.

Video: Tutoriales C++ Ep 3: Variables DOUBLE

Un ordenador sólo tiene una cantidad finita de memoria y una cantidad finita de precisión. Por lo tanto, tiene que terminar, lo que se traduce en una pequeña (pero real) de error.

C ++ puede corregir errores de redondeo en muchos casos. Por ejemplo, en la salida si una variable es ,99999999999999, C ++ se acaba de asumir que es realmente 1,0 y mostrarlo en consecuencia. Sin embargo, C ++ no puede corregir todos los errores de redondeo de punto flotante, por lo que hay que tener cuidado. Por ejemplo, no se puede estar seguro de que 1/3 + 1/3 + 1/3 es igual a 1,0:

doble d1 = 23,0 doble d2 = D1 / 7,0-Si (d1 == (d2 * 7,0)) {cout lt; lt; "Hemos llegado hasta aquí?" lt; lt; endl-}

Se podría pensar que este fragmento de código siempre se mostrará el “Hemos llegado hasta aquí?” cadena, pero sorprendentemente no lo hace. El problema es que 23 dividido por 7 no se puede expresar exactamente en un número de coma flotante. Algo se pierde. Así d2 * 7 está muy cerca de 23, pero no es exactamente igual.

En lugar de buscar la igualdad exacta entre dos números de punto flotante, que se debería hacer, “¿Es d2 * 7 infinitamente cerca de D1 en el valor?” Usted puede hacer eso de la siguiente manera:

doble d2 d1 = 23,0 doble = d1 / 7,0 - // Es d2 * 7.0 dentro delta del d1 = doble diferencia (d2 * 7,0) - d1-doble delta = 0,00001-Si (diferencia lt; delta && diferencia gt; -delta) {cout lt; lt; "Hemos llegado hasta aquí?" lt; lt; endl-}

Este fragmento de código calcula la diferencia entre d1 y d2 * 7.0. Si esta diferencia es menor que un pequeño delta, el código llama un día y dice que d1 y d2 * 7 son esencialmente iguales.

No tan limitada gama de doble

El número más grande que una tienda de doble lata es más o menos 10 a la potencia 38a. Eso es un 1 con 38 ceros después de IT que se come a los 2 mil millones tamaño máximo insignificante para un int para el desayuno. Eso es aún más que la deuda nacional (al menos, en el momento de escribir estas líneas). Probablemente hay aplicaciones en las 38 ceros no son suficientes.

Recuerde que sólo los 16 primeros dígitos son significativos. Los 22 dígitos restantes son el ruido, que ya ha sucumbido al error de redondeo de punto flotante estándar.